name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Mathlib.Tactic.ByCases.byCases! | Mathlib.Tactic.ByCases | Lean.ParserDescr | true |
Nat.Prime.factorization_pos_of_dvd | Mathlib.Data.Nat.Factorization.Defs | ∀ {n p : ℕ}, Nat.Prime p → n ≠ 0 → p ∣ n → 0 < n.factorization p | true |
CategoryTheory.ObjectProperty.instFullFullSubcategoryLift | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(P : CategoryTheory.ObjectProperty D) (F : CategoryTheory.Functor C D) (hF : ∀ (X : C), P (F.obj X)) [F.Full],
(P.lift F hF).Full | true |
measurePreserving_quotientAddGroup_mk_of_AddQuotientMeasureEqMeasurePreimage | Mathlib.MeasureTheory.Measure.Haar.Quotient | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] (ν : MeasureTheory.Measure G) {Γ : AddSubgroup G}
{𝓕 : Set G},
MeasureTheory.IsAddFundamentalDomain (↥Γ.op) 𝓕 ν →
∀ (μ : MeasureTheory.Measure (G ⧸ Γ)) [MeasureTheory.AddQuotientMeasureEqMeasurePreimage ν μ],
MeasureTheory.MeasurePreservi... | true |
one_lt_mabs_pos_of_one_lt | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LinearOrder α] [MulLeftMono α] {a : α}, 1 < a → 1 < |a|ₘ | true |
FreeAddGroup.reduce_cons_reduce | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} {L : List (α × Bool)} [inst : DecidableEq α] (a : α × Bool),
FreeAddGroup.reduce (a :: FreeAddGroup.reduce L) = FreeAddGroup.reduce (a :: L) | true |
Std.Tactic.BVDecide.LRAT.Parser.Binary.parseZero | Std.Tactic.BVDecide.LRAT.Parser | Std.Internal.Parsec.ByteArray.Parser Unit | true |
WeierstrassCurve.twoTorsionPolynomial_of_char_two | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [CharP R 2],
W.twoTorsionPolynomial = { a := 0, b := W.b₂, c := 0, d := W.b₆ } | true |
_private.Init.Data.Vector.Zip.0.Vector.getElem?_zipWith_eq_some._simp_1_1 | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {as : Array α} {bs : Array β} {z : γ} {i : ℕ},
((Array.zipWith f as bs)[i]? = some z) = ∃ x y, as[i]? = some x ∧ bs[i]? = some y ∧ f x y = z | false |
GradedEquivLike.rec | Mathlib.Data.FunLike.Graded | {E : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_4} →
{τ : Type u_5} →
{ι : Type u_6} →
[inst : SetLike σ A] →
[inst_1 : SetLike τ B] →
{𝒜 : ι → σ} →
{ℬ : ι → τ} →
[inst_2 : EquivLike E A B] →
... | false |
SimpleGraph.Subgraph.disjoint_verts_iff_disjoint._simp_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph}, Disjoint H.verts H'.verts = Disjoint H H' | false |
_private.Mathlib.Order.WithBot.0.WithTop.denselyOrdered_iff._simp_1_3 | Mathlib.Order.WithBot | ∀ {α : Type u_3} {inst : LT α} [self : NoMaxOrder α] (a : α), (∃ b, a < b) = True | false |
IsLocalizedModule.fromLocalizedModule'_smul | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] (r : R) (x : LocalizedModule S M),
r • IsLocalizedModule.fromLocalizedModu... | true |
Vector.getElem?_set_self | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {xs : Vector α n} {x : α} (hi : i < n), (xs.set i x hi)[i]? = some x | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalClearValue.match_3 | Lean.Elab.Tactic.BuiltinTactic | (motive : MProd Lean.MVarId Bool → Sort u_1) →
(x : MProd Lean.MVarId Bool) → ((g : Lean.MVarId) → (succeeded : Bool) → motive ⟨g, succeeded⟩) → motive x | false |
Seminorm.uniformSpace_eq_of_hasBasis | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NontriviallyNormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{ι : Sort u_12} [inst_3 : UniformSpace E] [IsUniformAddGroup E] [ContinuousConstSMul 𝕜 E] {p' : ι → Prop}
{s : ι → Set E} (p : Seminorm 𝕜 E),
(nhds 0).HasBasis p' s →
(∃ r, p.closedBall 0 r ... | true |
CategoryTheory.Presieve.functorPullback_map_functorPullback | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X : C} (R : CategoryTheory.Presieve (F.obj X)),
CategoryTheory.Presieve.functorPullback F
(CategoryTheory.Presieve.map F (CategoryTheory.Presieve.functorPul... | true |
Aesop.Frontend.Feature.term.inj | Aesop.Frontend.RuleExpr | ∀ {i i_1 : Lean.Term}, Aesop.Frontend.Feature.term i = Aesop.Frontend.Feature.term i_1 → i = i_1 | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
_private.Mathlib.Combinatorics.Matroid.Sum.0.Matroid.sum_isBase_iff._simp_1_4 | Mathlib.Combinatorics.Matroid.Sum | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | false |
funext₂ | Batteries.Logic | ∀ {α : Sort u_1} {β : α → Sort u_2} {γ : (a : α) → β a → Sort u_3} {f g : (a : α) → (b : β a) → γ a b},
(∀ (a : α) (b : β a), f a b = g a b) → f = g | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_insert._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
CategoryTheory.Equivalence.cancel_counitInv_right_assoc'._simp_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D) {W X X' Y Y' Z : D} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z) (f' : W ⟶ X') (g' : X' ⟶ Y') (h' : Y' ⟶ Z),
(CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp g ... | false |
ProofWidgets.ExprPresentationProps.mk.noConfusion | ProofWidgets.Presentation.Expr | {P : Sort u} →
{expr expr' : Lean.Server.WithRpcRef ProofWidgets.ExprWithCtx} →
{ expr := expr } = { expr := expr' } → (expr = expr' → P) → P | false |
Poly.instAdd | Mathlib.NumberTheory.Dioph | {α : Type u_1} → Add (Poly α) | true |
MeasureTheory.Measure.notMem_support_iff | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] {μ : MeasureTheory.Measure X} {x : X},
x ∉ μ.support ↔ ∀ᶠ (u : Set X) in (nhds x).smallSets, μ u = 0 | true |
CategoryTheory.LocalizerMorphism.commShift_iso_hom_app_assoc | Mathlib.CategoryTheory.Shift.Localization | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {M : Type u_3}
[inst_2 : AddMonoid M] [inst_3 : Categor... | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.existsRatHint_of_ratHintsExhaustive._proof_1_15 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (i : ℕ)
(i_in_bounds : i < (Array.range f.clauses.size).size),
i < f.clauses.size → i = (Array.range f.clauses.size)[i] → (Array.range f.clauses.size)[i] < f.clauses.size | false |
_private.Init.Data.List.Lemmas.0.List.getLast?_eq_some_iff.match_1_3 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {a : α} (motive : (∃ ys, xs = ys ++ [a]) → Prop) (x : ∃ ys, xs = ys ++ [a]),
(∀ (ys : List α) (h : xs = ys ++ [a]), motive ⋯) → motive x | false |
Rep.standardResolution._proof_2 | Mathlib.RepresentationTheory.Homological.Resolution | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G], QuasiIso (Rep.standardComplex.εToSingle₀ k G) | false |
Submodule.giMapComap | Mathlib.Algebra.Module.Submodule.Map | {R : Type u_1} →
{R₂ : Type u_3} →
{M : Type u_5} →
{M₂ : Type u_7} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
[inst_5 : Module R₂ M₂] →
... | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.ofNat_div._simp_1_1 | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt16), (UInt16.ofNat a = b) = (a % 2 ^ 16 = b.toNat) | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.isExample | Lean.Elab.MutualDef | Array Lean.Elab.DefView → Bool | true |
Metric.Snowflaking.recOn | Mathlib.Topology.MetricSpace.Snowflaking | {X : Type u_1} →
{α : ℝ} →
{hα₀ : 0 < α} →
{hα₁ : α ≤ 1} →
{motive : Metric.Snowflaking X α hα₀ hα₁ → Sort u} →
(t : Metric.Snowflaking X α hα₀ hα₁) → ((val : X) → motive { val := val }) → motive t | false |
Lean.LocalDeclKind.ofNat | Lean.LocalContext | ℕ → Lean.LocalDeclKind | true |
RootPairing.linearIndependent_iff_coxeterWeight_ne_four | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) {i j : ι} [Finite ι]
[CharZero R] [IsDomain R] [Module.IsTorsionFree R M],
LinearIndependent R ![P.root i, P.r... | true |
CategoryTheory.ThinSkeleton.thinSkeletonPartialOrder._proof_1 | Mathlib.CategoryTheory.Skeletal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [Quiver.IsThin C] (a b : C),
⟦a⟧ ≤ ⟦b⟧ → ⟦b⟧ ≤ ⟦a⟧ → ⟦a⟧ = ⟦b⟧ | false |
_private.Mathlib.Data.Nat.Squarefree.0.Nat.primeFactors_div_gcd._simp_1_2 | Mathlib.Data.Nat.Squarefree | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
TProd.instMeasurableSpace | Mathlib.MeasureTheory.MeasurableSpace.Constructions | {δ : Type u_4} →
(X : δ → Type u_6) → [(i : δ) → MeasurableSpace (X i)] → (l : List δ) → MeasurableSpace (List.TProd X l) | true |
Rack.PreEnvelGroup.setoid | Mathlib.Algebra.Quandle | (R : Type u_1) → [Rack R] → Setoid (Rack.PreEnvelGroup R) | true |
primorial_lt_four_pow | Mathlib.NumberTheory.Primorial | ∀ (n : ℕ), n ≠ 0 → primorial n < 4 ^ n | true |
TopologicalSpace.Opens.adjunction_counit_app_self._proof_2 | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U : TopologicalSpace.Opens ↑X),
((TopologicalSpace.Opens.map U.inclusion').comp ⋯.functor).obj U =
(CategoryTheory.Functor.id (TopologicalSpace.Opens ↑X)).obj U | false |
antitoneOn_of_hasDerivWithinAt_nonpos | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {D : Set ℝ},
Convex ℝ D →
∀ {f f' : ℝ → ℝ},
ContinuousOn f D →
(∀ x ∈ interior D, HasDerivWithinAt f (f' x) (interior D) x) → (∀ x ∈ interior D, f' x ≤ 0) → AntitoneOn f D | true |
Mathlib.Tactic.Borelize._aux_Mathlib_MeasureTheory_Constructions_BorelSpace_Basic___elabRules_Mathlib_Tactic_Borelize_tacticBorelize____1 | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | Lean.Elab.Tactic.Tactic | false |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkEqTrans.match_1 | Lean.Meta.AppBuilder | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x x_1 : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((α a b fst fst_1 c : Lean.Expr) → motive (some (α, a, b)) (some (fst, fst_1, c))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) → moti... | false |
ProbabilityTheory.condIndepSet_iff_condIndep | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} (m' : MeasurableSpace Ω) {mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] (hm' : m' ≤ mΩ)
(s t : Set Ω) (μ : MeasureTheory.Measure Ω) [inst_1 : MeasureTheory.IsFiniteMeasure μ],
ProbabilityTheory.CondIndepSet m' hm' s t μ ↔
ProbabilityTheory.CondIndep m' (MeasurableSpace.generateFrom {s})... | true |
Monotone.tendstoUniformlyOn_of_forall_tendsto | Mathlib.Topology.UniformSpace.Dini | ∀ {ι : Type u_1} {α : Type u_2} {G : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α]
[inst_2 : NormedAddCommGroup G] [inst_3 : Lattice G] [HasSolidNorm G] [IsOrderedAddMonoid G] {F : ι → α → G}
{f : α → G} {s : Set α},
IsCompact s →
(∀ (i : ι), ContinuousOn (F i) s) →
(∀ x ∈ s, Monotone fun ... | true |
_private.Mathlib.ModelTheory.Syntax.0.FirstOrder.Language.Term.varsToConstants.match_1.eq_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u_3} {γ : Type u_4} (motive : L.Term (γ ⊕ α) → Sort u_5) (c : γ)
(h_1 : (a : α) → motive (FirstOrder.Language.var (Sum.inr a)))
(h_2 : (c : γ) → motive (FirstOrder.Language.var (Sum.inl c)))
(h_3 : (l : ℕ) → (f : L.Functions l) → (ts : Fin l → L.Term (γ ⊕ α)) → motive (FirstO... | true |
CategoryTheory.Discrete.addMonoidal._proof_2 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ (M : Type u_1) [inst : AddMonoid M] {X₁ X₂ : CategoryTheory.Discrete M} (f : X₁ ⟶ X₂) (X : CategoryTheory.Discrete M),
{ as := X₁.as + X.as } = { as := X₂.as + X.as } | false |
DFinsupp.support_mk'_subset._simp_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] {f : (i : ι) → β i} {s : Multiset ι}
{h : ∀ (i : ι), i ∈ s ∨ f i = 0}, ({ toFun := f, support' := Trunc.mk ⟨s, h⟩ }.support ⊆ s.toFinset) = True | false |
MeasureTheory.volume_preserving_piFinsetUnion | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_4} [inst : DecidableEq ι] (α : ι → Type u_5) {s t : Finset ι} (h : Disjoint s t)
[inst_1 : (i : ι) → MeasureTheory.MeasureSpace (α i)] [∀ (i : ι), MeasureTheory.SigmaFinite MeasureTheory.volume],
MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piFinsetUnion α h)) MeasureTheory.volume MeasureTheory.... | true |
NNReal.exists_mem_Ioc_zpow | Mathlib.Data.NNReal.Defs | ∀ {x y : NNReal}, x ≠ 0 → 1 < y → ∃ n, x ∈ Set.Ioc (y ^ n) (y ^ (n + 1)) | true |
PositiveLinearMap.leftMulMapPreGNS._proof_6 | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A], ContinuousConstSMul ℂ A | false |
_private.Lean.Meta.FunInfo.0.Lean.Meta.checkFunInfoCache.match_1 | Lean.Meta.FunInfo | (motive : Lean.Expr → Sort u_1) →
(fn : Lean.Expr) →
((c : Lean.Name) → (ls : List Lean.Level) → motive (Lean.Expr.const c ls)) →
((x : Lean.Expr) → motive x) → motive fn | false |
LinearIsometryEquiv.ofEq._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {R' : Type u_2} [inst_1 : Ring R'] [inst_2 : Module R' E]
(p q : Submodule R' E) (hpq : p = q) (x : ↥p), ‖(LinearEquiv.ofEq p q hpq) x‖ = ‖(LinearEquiv.ofEq p q hpq) x‖ | false |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.deriveInductionStructural.match_13 | Lean.Meta.Tactic.FunInd | (motive : Option (ℕ × Subarray ℕ) → Sort u_1) →
(x : Option (ℕ × Subarray ℕ)) →
(Unit → motive none) → ((numTargets : ℕ) → (s' : Subarray ℕ) → motive (some (numTargets, s'))) → motive x | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₁_eq_some_iff_utf8EncodeChar_eq._simp_1_6 | Init.Data.String.Decode | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) | false |
_private.Mathlib.Order.MinMax.0.max_eq_iff._proof_1_1 | Mathlib.Order.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, max a b = c ↔ a = c ∧ b ≤ a ∨ b = c ∧ a ≤ b | false |
IO.TaskState | Init.System.IO | Type | true |
ChainCompletePartialOrder.noConfusionType | Mathlib.Order.BourbakiWitt | Sort u → {α : Type u_2} → ChainCompletePartialOrder α → {α' : Type u_2} → ChainCompletePartialOrder α' → Sort u | false |
PadicInt.lift_unique | Mathlib.NumberTheory.Padics.RingHoms | ∀ {R : Type u_1} [inst : NonAssocSemiring R] {p : ℕ} {f : (k : ℕ) → R →+* ZMod (p ^ k)} [hp_prime : Fact (Nat.Prime p)]
(f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), (ZMod.castHom ⋯ (ZMod (p ^ k1))).comp (f k2) = f k1) (g : R →+* ℤ_[p]),
(∀ (n : ℕ), (PadicInt.toZModPow n).comp g = f n) → PadicInt.lift f_compat = g | true |
Algebra.SubmersivePresentation.recOn | Mathlib.RingTheory.Extension.Presentation.Submersive | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : Finite σ] →
{motive : Algebra.SubmersivePresentation R S ι σ → Sort u_1} →
(t : Algebra.S... | false |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.basicOpen_eq_bot_iff._simp_1_2 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | false |
_private.Mathlib.GroupTheory.Perm.Sign.0.Equiv.Perm.signAux_swap._simp_1_4 | Mathlib.GroupTheory.Perm.Sign | (¬True) = False | false |
ContinuousMap.coe_star | Mathlib.Topology.ContinuousMap.Star | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Star β]
[inst_3 : ContinuousStar β] (f : C(α, β)), ⇑(star f) = star ⇑f | true |
Submonoid.unop | Mathlib.Algebra.Group.Submonoid.MulOpposite | {M : Type u_2} → [inst : MulOneClass M] → Submonoid Mᵐᵒᵖ → Submonoid M | true |
Set.notMem_Icc_of_lt | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b c : α}, c < a → c ∉ Set.Icc a b | true |
LieHom.quotKerEquivRange._proof_7 | Mathlib.Algebra.Lie.Quotient | ∀ {R : Type u_3} {L : Type u_1} {L' : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (f : L →ₗ⁅R⁆ L'),
Function.RightInverse (↑f).quotKerEquivRange.invFun (↑(↑f).quotKerEquivRange).toFun | false |
Lean.Meta.Sym.Simp.Result.step | Lean.Meta.Sym.Simp.SimpM | Lean.Expr → Lean.Expr → optParam Bool false → Lean.Meta.Sym.Simp.Result | true |
CategoryTheory.CartesianMonoidalCategory.lift_leftUnitor_hom_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] {X Y : C}
(f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C) (g : X ⟶ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianMonoidalCategory.lift f g)
(Categor... | true |
Subsemigroup.opEquiv_apply | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] (x : Subsemigroup M), Subsemigroup.opEquiv x = x.op | true |
Lean.Language.Snapshot.Diagnostics.ctorIdx | Lean.Language.Basic | Lean.Language.Snapshot.Diagnostics → ℕ | false |
Real.instDivInvMonoid._proof_1 | Mathlib.Data.Real.Basic | ∀ (a b : ℝ), a / b = a * b⁻¹ | false |
MonadCont.goto | Mathlib.Control.Monad.Cont | {α : Type u_1} → {β : Type u} → {m : Type u → Type v} → MonadCont.Label α m β → α → m β | true |
NONote.instInhabited | Mathlib.SetTheory.Ordinal.Notation | Inhabited NONote | true |
Nat.lt_base_pow_length_digits | Mathlib.Data.Nat.Digits.Defs | ∀ {b m : ℕ}, 1 < b → m < b ^ (b.digits m).length | true |
_private.Mathlib.MeasureTheory.Measure.LevyProkhorovMetric.0.MeasureTheory.LevyProkhorov.continuous_toMeasure_probabilityMeasure._simp_1_5 | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b | false |
Filter.tendsto_top._simp_1 | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : Filter α}, Filter.Tendsto f l ⊤ = True | false |
PosPart.mk.noConfusion | Mathlib.Algebra.Notation | {α : Type u_1} →
{P : Sort u} →
{posPart posPart' : α → α} → { posPart := posPart } = { posPart := posPart' } → (posPart ≍ posPart' → P) → P | false |
CategoryTheory.Comon.instInhabited | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → Inhabited (CategoryTheory.Comon C) | true |
Lean.Environment.Replay.replayConstant._unsafe_rec | Lean.Replay | Lean.Name → Lean.Environment.Replay.M Unit | false |
LE.le.lt_or_ge | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, b ≤ a → ∀ (c : α), c < a ∨ b ≤ c | true |
Aesop.MonadStats.modifyStats._default | Aesop.Stats.Basic | {m : Type → Type} → ({α : Type} → (Aesop.Stats → α × Aesop.Stats) → m α) → (Aesop.Stats → Aesop.Stats) → m Unit | false |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.alter_eq_empty_iff_erase_eq_empty._simp_1_4 | Std.Data.ExtDHashMap.Lemmas | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) | false |
uniformEquicontinuous_of_equicontinuousAt_zero | Mathlib.Topology.Algebra.Equicontinuity | ∀ {ι : Type u_1} {G : Type u_2} {M : Type u_3} {hom : Type u_4} [inst : UniformSpace G] [inst_1 : UniformSpace M]
[inst_2 : AddGroup G] [inst_3 : AddGroup M] [IsUniformAddGroup G] [IsUniformAddGroup M] [inst_6 : FunLike hom G M]
[AddMonoidHomClass hom G M] (F : ι → hom),
EquicontinuousAt (DFunLike.coe ∘ F) 0 → Un... | true |
Lean.Declaration.forExprM | Lean.Declaration | {m : Type → Type} → [Monad m] → Lean.Declaration → (Lean.Expr → m Unit) → m Unit | true |
instCommMonoidPNat | Mathlib.Data.PNat.Basic | CommMonoid ℕ+ | true |
Polynomial.instCommRingSplittingField._proof_22 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K] (f : Polynomial K) (a : f.SplittingField), 1 * a = a | false |
Sum.liftRel_subrelation_lex | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop}, Subrelation (Sum.LiftRel r s) (Sum.Lex r s) | true |
LinearMap.separatingRight_iff_det_ne_zero | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M₁ : Type u_6} {m : Type u_12} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m]
[IsDomain R] [inst_4 : AddCommMonoid M₁] [inst_5 : Module R M₁] (b : Module.Basis m R M₁) {B : M₁ →ₗ[R] M₁ →ₗ[R] R},
B.SeparatingRight ↔ ((LinearMap.toMatrix₂ b b) B).det ≠ 0 | true |
CategoryTheory.Triangulated.SpectralObject.instCategory._proof_2 | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_4} {ι : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} ι] [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Addit... | false |
_private.Mathlib.Data.WSeq.Basic.0.Computation.Corec.f.match_1.eq_1 | Mathlib.Data.WSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} (motive : α ⊕ β → Sort u_3) (a : α) (h_1 : (a : α) → motive (Sum.inl a))
(h_2 : (val : β) → motive (Sum.inr val)),
(match Sum.inl a with
| Sum.inl a => h_1 a
| Sum.inr val => h_2 val) =
h_1 a | true |
IsFractionRing.coeSubmodule_injective | Mathlib.RingTheory.Localization.Submodule | ∀ (R : Type u_3) (K : Type u_4) [inst : CommRing R] [inst_1 : CommRing K] [inst_2 : Algebra R K] [IsFractionRing R K],
Function.Injective (IsLocalization.coeSubmodule K) | true |
Array.back?_filterMap | Init.Data.Array.Find | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {xs : Array α},
(Array.filterMap f xs).back? = Array.findSomeRev? f xs | true |
Simps.instInhabitedProjectionData.default | Mathlib.Tactic.Simps.Basic | Simps.ProjectionData | true |
Monotone.inter | Mathlib.Data.Set.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : β → Set α},
Monotone f → Monotone g → Monotone fun x => f x ∩ g x | true |
ContinuousLinearMap.map_add₂ | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {R : Type u_1} {𝕜₂ : Type u_3} {𝕜₃ : Type u_4} {E : Type u_5} {F : Type u_6} {G : Type u_7} [inst : Semiring R]
[inst_1 : NormedField 𝕜₂] [inst_2 : NormedField 𝕜₃] [inst_3 : AddCommMonoid E] [inst_4 : Module R E]
[inst_5 : TopologicalSpace E] [inst_6 : AddCommGroup F] [inst_7 : Module 𝕜₂ F] [inst_8 : Topolog... | true |
_private.Mathlib.Tactic.Simps.Basic.0.Simps.elabSimpsConfig.match_1 | Mathlib.Tactic.Simps.Basic | (motive : DoResultPR Simps.Config Simps.Config PUnit.{1} → Sort u_1) →
(r : DoResultPR Simps.Config Simps.Config PUnit.{1}) →
((a : Simps.Config) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Simps.Config) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r | false |
AlgebraicGeometry.Scheme.Hom.normalizationDesc._proof_5 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : (AlgebraicGeometry.Scheme.AffineZariskiSite.directedCover Y).I₀),
SubsemiringClass
(Subalgebra
↑(Y.presheaf.obj
(Opposite.op
(Opposite.unop ((AlgebraicGeometry.Scheme.AffineZariskiSite.toOpensFunctor Y).op.obj (Opposite.op U)))))
... | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_428 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.