name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ArchimedeanClass.mem_closedBallAddSubgroup_iff | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {a : M}
{c : ArchimedeanClass M}, a ∈ c.closedBallAddSubgroup ↔ c ≤ ArchimedeanClass.mk a | true |
ZeroHom.instAddCommGroup | Mathlib.Algebra.Group.Hom.Instances | {M : Type uM} → {N : Type uN} → [inst : Zero M] → [inst_1 : AddCommGroup N] → AddCommGroup (ZeroHom M N) | true |
ExteriorAlgebra.ι_eq_algebraMap_iff._simp_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : M) (r : R),
((ExteriorAlgebra.ι R) x = (algebraMap R (ExteriorAlgebra R M)) r) = (x = 0 ∧ r = 0) | false |
Lean.Elab.Tactic.Do.ProofMode.TypeList.mkType | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Level → Lean.Expr | true |
_private.Mathlib.Tactic.ErwQuestion.0.Mathlib.Tactic.Erw?._aux_Mathlib_Tactic_ErwQuestion___elabRules_Mathlib_Tactic_Erw?_erw?_1.match_3 | Mathlib.Tactic.ErwQuestion | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr) → ((tgt inferred : Lean.Expr) → motive (tgt, inferred)) → motive __discr | false |
Set.instLawfulMonad | Mathlib.Data.Set.Functor | LawfulMonad Set | true |
Std.TreeSet.instInsert | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → Insert α (Std.TreeSet α cmp) | true |
NonnegHomClass.casesOn | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : Zero β] →
[inst_1 : LE β] →
[inst_2 : FunLike F α β] →
{motive : NonnegHomClass F α β → Sort u} →
(t : NonnegHomClass F α β) → ((apply_nonneg : ∀ (f : F) (a : α), 0 ≤ f a) → motive ⋯) → motive t | false |
Subgroup.coe_toSubmonoid | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G), ↑K.toSubmonoid = ↑K | true |
Nat.primeFactorsList_sublist_of_dvd | Mathlib.Data.Nat.Factors | ∀ {n k : ℕ}, n ∣ k → k ≠ 0 → n.primeFactorsList.Sublist k.primeFactorsList | true |
Lean.Elab.Do.MonadInfo.noConfusion | Lean.Elab.Do.Basic | {P : Sort u} → {t t' : Lean.Elab.Do.MonadInfo} → t = t' → Lean.Elab.Do.MonadInfo.noConfusionType P t t' | false |
_private.Batteries.Data.List.Lemmas.0.List.findIdxs_take._proof_1_3 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {s : ℕ},
List.findIdxs p (List.take 0 (head :: tail)) s =
List.take (List.countP p (List.take 0 (head :: tail))) (List.findIdxs p (head :: tail) s) | false |
Mathlib.Meta.FunProp.Mor.getAppArgs | Mathlib.Tactic.FunProp.Mor | Lean.Expr → Lean.MetaM (Array Mathlib.Meta.FunProp.Mor.Arg) | true |
LinearOrderedAddCommGroup.isAddCyclic_iff_nonempty_equiv_int | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {A : Type u_4} [inst : AddCommGroup A] [inst_1 : LinearOrder A] [IsOrderedAddMonoid A] [Nontrivial A],
IsAddCyclic A ↔ Nonempty (A ≃+o ℤ) | true |
Set.InjOn.ne_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {x y : α}, Set.InjOn f s → x ∈ s → y ∈ s → (f x ≠ f y ↔ x ≠ y) | true |
Polynomial.instEuclideanDomain | Mathlib.Algebra.Polynomial.FieldDivision | {R : Type u} → [inst : Field R] → EuclideanDomain (Polynomial R) | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0._regBuiltin.Nat.reduceAnd.declare_56._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.1489869653._hygCtx._hyg.19 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | false |
Lean.Meta.RecursorUnivLevelPos.majorType.injEq | Lean.Meta.RecursorInfo | ∀ (idx idx_1 : ℕ),
(Lean.Meta.RecursorUnivLevelPos.majorType idx = Lean.Meta.RecursorUnivLevelPos.majorType idx_1) = (idx = idx_1) | true |
StarAlgHom.copy._proof_3 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] (f : A →⋆ₐ[R] B) (f' : A → B),
f' = ⇑f → f' 0 = 0 | false |
Lean.Elab.Term.Do.Code.reassign.inj | Lean.Elab.Do.Legacy | ∀ {xs : Array Lean.Elab.Term.Do.Var} {doElem : Lean.Syntax} {k : Lean.Elab.Term.Do.Code}
{xs_1 : Array Lean.Elab.Term.Do.Var} {doElem_1 : Lean.Syntax} {k_1 : Lean.Elab.Term.Do.Code},
Lean.Elab.Term.Do.Code.reassign xs doElem k = Lean.Elab.Term.Do.Code.reassign xs_1 doElem_1 k_1 →
xs = xs_1 ∧ doElem = doElem_1 ∧... | true |
Std.DTreeMap.Internal.Impl.ExplorationStep.lt.injEq | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {k : α → Ordering} (a : α) (a_1 : k a = Ordering.lt) (a_2 : β a)
(a_3 : List ((a : α) × β a)) (a_4 : α) (a_5 : k a_4 = Ordering.lt) (a_6 : β a_4) (a_7 : List ((a : α) × β a)),
(Std.DTreeMap.Internal.Impl.ExplorationStep.lt a a_1 a_2 a_3 =
Std.DTreeMap.Internal.Im... | true |
IsOrderedAddMonoid.toIsOrderedCancelAddMonoid | Mathlib.Algebra.Order.Group.Defs | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α], IsOrderedCancelAddMonoid α | true |
Std.Format.nest.elim | Init.Data.Format.Basic | {motive : Std.Format → Sort u} →
(t : Std.Format) → t.ctorIdx = 4 → ((indent : ℤ) → (f : Std.Format) → motive (Std.Format.nest indent f)) → motive t | false |
Denumerable.ofEncodableOfInfinite._proof_1 | Mathlib.Logic.Denumerable | ∀ (α : Type u_1) [inst : Encodable α] [Infinite α], Infinite ↑(Set.range Encodable.encode) | false |
Std.DTreeMap.Raw.partition.eq_1 | Std.Data.DTreeMap.Raw.WF | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (f : (a : α) → β a → Bool) (t : Std.DTreeMap.Raw α β cmp),
Std.DTreeMap.Raw.partition f t =
Std.DTreeMap.Raw.foldl
(fun x a b =>
match x with
| (l, r) => if f a b = true then (l.insert a b, r) else (l, r.insert a b))
(∅, ∅) t | true |
InnerProductSpace.gramSchmidt_ne_zero_coe | Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_3} [inst_3 : LinearOrder ι] [inst_4 : LocallyFiniteOrderBot ι] [inst_5 : WellFoundedLT ι] {f : ι → E}
(n : ι), LinearIndependent 𝕜 (f ∘ Subtype.val) → InnerProductSpace.gramSchmidt 𝕜 f... | true |
Affine.Simplex.circumcenter_eq_affineCombination_of_pointsWithCircumcenter | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n),
s.circumcenter =
(Finset.affineCombination ℝ Finset.univ s.pointsWithCircumcenter)
(Affine.Simplex.circumcenterWeightsW... | true |
cfcₙ_neg | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommRing R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalRing R] [inst_5 : ContinuousStar R] [inst_6 : TopologicalSpace A]
[inst_7 : NonUnitalRing A] [inst_8 : StarRing A] [inst_9 : Module R A] [inst_10 : IsScala... | true |
Set.notMem_of_notMem_sUnion | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {x : α} {t : Set α} {S : Set (Set α)}, x ∉ ⋃₀ S → t ∈ S → x ∉ t | true |
CategoryTheory.Limits.HasCountableLimits.recOn | Mathlib.CategoryTheory.Limits.Shapes.Countable | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Limits.HasCountableLimits C → Sort u} →
(t : CategoryTheory.Limits.HasCountableLimits C) →
((out :
∀ (J : Type) [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.CountableCategory J],
... | false |
USize.and_le_left | Init.Data.UInt.Bitwise | ∀ {a b : USize}, a &&& b ≤ a | true |
Cycle.support_formPerm | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (s : Cycle α) (h : s.Nodup),
s.Nontrivial → (s.formPerm h).support = s.toFinset | true |
right_iff_ite_iff | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x y : Prop}, (y ↔ if p then x else y) ↔ p → y = x | true |
CategoryTheory.TwistShiftData.z_zero_right | Mathlib.CategoryTheory.Shift.Twist | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (t : CategoryTheory.TwistShiftData C A) (a : A), t.z a 0 = 1 | true |
exists_smooth_forall_mem_convex_of_local_const | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type uF} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {H : Type uH} [inst_4 : TopologicalSpace H] (I : ModelWithCorners ℝ E H) {M : Type uM}
[inst_5 : TopologicalSpace M] [inst_6 : ChartedSpace H M] [FiniteDimensional ℝ E] [... | true |
isPreconnected_iff_subset_of_fully_disjoint_closed | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α},
IsClosed s → (IsPreconnected s ↔ ∀ (u v : Set α), IsClosed u → IsClosed v → s ⊆ u ∪ v → Disjoint u v → s ⊆ u ∨ s ⊆ v) | true |
Submodule.rank_quotient_add_rank | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_1} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_1} R] (N : Submodule R M), Module.rank R (M ⧸ N) + Module.rank R ↥N = Module.rank R M | true |
FundamentalGroup.map | Mathlib.AlgebraicTopology.FundamentalGroupoid.FundamentalGroup | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → (f : C(X, Y)) → (x : X) → FundamentalGroup X x →* FundamentalGroup Y (f x) | true |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.eventually_notMem_cthickening_of_infEDist_pos._simp_1_2 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Lean.Meta.Grind.MBTC.Context.mk.noConfusion | Lean.Meta.Tactic.Grind.MBTC | {P : Sort u} →
{isInterpreted hasTheoryVar : Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{eqAssignment : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{isInterpreted' hasTheoryVar' : Lean.Expr → Lean.Meta.Grind.GoalM Bool} →
{eqAssignment' : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool} ... | false |
Submonoid.LocalizationMap.mk'_eq_zero_iff | Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoidWithZero N]
(f : S.LocalizationMap N) (m : M) (s : ↥S), f.mk' m s = 0 ↔ ∃ s, ↑s * m = 0 | true |
_private.Mathlib.RingTheory.Ideal.Operations.0.Submodule.smul_le_span._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] (s : Set R), Ideal.span s = s • ⊤ | false |
Encodable.chooseX.match_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {p : α → Prop} (motive : (∃ x, p x) → Prop) (h : ∃ x, p x), (∀ (w : α) (pw : p w), motive ⋯) → motive h | false |
_private.Mathlib.Combinatorics.SimpleGraph.Prod.0.SimpleGraph.reachable_boxProd.match_1_3 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {H : SimpleGraph β} {x y : α × β}
(motive : G.Reachable x.1 y.1 ∧ H.Reachable x.2 y.2 → Prop) (h : G.Reachable x.1 y.1 ∧ H.Reachable x.2 y.2),
(∀ (w₁ : G.Walk x.1 y.1) (w₂ : H.Walk x.2 y.2), motive ⋯) → motive h | false |
PrimeSpectrum.BasicConstructibleSetData.recOn | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} →
{motive : PrimeSpectrum.BasicConstructibleSetData R → Sort u} →
(t : PrimeSpectrum.BasicConstructibleSetData R) →
((f : R) → (n : ℕ) → (g : Fin n → R) → motive { f := f, n := n, g := g }) → motive t | false |
PolynomialLaw.toFun'_eq_of_inclusion | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {S : Type v} [inst_5 : CommSemiring S] [inst_6 : Algebra R S]
(f : M →ₚₗ[R] N) {A : Type u} [inst_7 : CommSemiring A] [inst_8 : Algebra R A] {φ : A →... | true |
List.SublistForall₂.recOn | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
{motive : (a : List α) → (a_1 : List β) → List.SublistForall₂ R a a_1 → Prop} {a : List α} {a_1 : List β}
(t : List.SublistForall₂ R a a_1),
(∀ {l : List β}, motive [] l ⋯) →
(∀ {a₁ : α} {a₂ : β} {l₁ : List α} {l₂ : List β} (a : R a₁ a₂) (a_2 : List.SublistFo... | false |
DistribMulActionHom.instCoeTCOfAddDistribAddActionSemiHomClassCoeAddMonoidHom.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : DistribMulAction M A] {B : Type u_5} [inst_4 : AddMonoid B] [inst_5 : DistribMulAction N B] {F : Type u_10}
[inst_6 : FunLike F A B] [inst_7 : DistribMulActionSemiHomClass F (⇑φ) A B],
... | true |
Monoid.PushoutI.NormalWord.head | Mathlib.GroupTheory.PushoutI | {ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} → {d : Monoid.PushoutI.NormalWord.Transversal φ} → Monoid.PushoutI.NormalWord d → H | true |
Std.Time.TimeZone.instInhabitedUTLocal.default | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.UTLocal | true |
Lean.Lsp.DidCloseTextDocumentParams | Lean.Data.Lsp.TextSync | Type | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergence.0.tendstoUniformlyOn_singleton_iff_tendsto._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ | false |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score.mk.sizeOf_spec | Lean.Data.FuzzyMatching | ∀ (inner : Int16), sizeOf { inner := inner } = 1 + sizeOf inner | true |
_private.Mathlib.RingTheory.IntegralClosure.IntegrallyClosed.0.Associated.pow_iff._simp_1_1 | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ {M : Type u_1} [inst : MonoidWithZero M] [IsLeftCancelMulZero M] {a b : M}, Associated a b = (a ∣ b ∧ b ∣ a) | false |
LibraryNote.norm_num_lemma_function_equality | Mathlib.Tactic.NormNum.Basic | Batteries.Util.LibraryNote | true |
AffineSubspace.instCompleteLattice._proof_2 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (x x_1 : AffineSubspace k P), ↑x ⊆ ↑(affineSpan k (↑x ∪ ↑x_1)) | false |
padicNormE.defn | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : PadicSeq p) {ε : ℚ},
0 < ε → ∃ N, ∀ i ≥ N, padicNormE (Padic.mk f - ↑(↑f i)) < ε | true |
Lean.Grind.CommRing.Expr.denote_toPoly | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) (e : Lean.Grind.CommRing.Expr),
Lean.Grind.CommRing.Poly.denote ctx e.toPoly = Lean.Grind.CommRing.Expr.denote ctx e | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreCommRing.injEq | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (a b : Lean.Expr) (ra rb : Lean.Grind.CommRing.Expr) (p : Lean.Grind.CommRing.Poly)
(lhs' : Lean.Meta.Grind.Arith.Linear.LinExpr) (a_1 b_1 : Lean.Expr) (ra_1 rb_1 : Lean.Grind.CommRing.Expr)
(p_1 : Lean.Grind.CommRing.Poly) (lhs'_1 : Lean.Meta.Grind.Arith.Linear.LinExpr),
(Lean.Meta.Grind.Arith.Linear.EqCnstrPr... | true |
Complex.HadamardThreeLines.sSupNormIm | Mathlib.Analysis.Complex.Hadamard | {E : Type u_1} → [NormedAddCommGroup E] → (ℂ → E) → ℝ → ℝ | true |
NonUnitalSubalgebra.toNonUnitalSubsemiring'._proof_2 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
(S T : NonUnitalSubalgebra R A), S.toNonUnitalSubsemiring = T.toNonUnitalSubsemiring → S = T | false |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.LetValue.toMono.match_3 | Lean.Compiler.LCNF.ToMono | (motive : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(x : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure) →
((resultFVar : Lean.FVarId) →
(binderName : Lean.Name) →
(type : Lean.Expr) →
(callName : Lean.Name) →
(us : List Lean... | false |
FirstOrder.Language.orderLHom_onRelation | Mathlib.ModelTheory.Order | ∀ (L : FirstOrder.Language) [inst : L.IsOrdered] (x : ℕ) (x_1 : FirstOrder.Language.order.Relations x),
L.orderLHom.onRelation x_1 =
match x, x_1 with
| .(2), FirstOrder.Language.orderRel.le => FirstOrder.Language.leSymb | true |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.findX._proof_13 | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} (p : Fin n → Prop) (h : ∃ k, p k) (m : ℕ),
(∀ (j : ℕ) (hm : j < n - (m + 1)), ¬p ⟨j, ⋯⟩) → ¬p ⟨n - (m + 1), ⋯⟩ → ∀ (j_1 : ℕ) (h_1 : j_1 < n - m), ¬p ⟨j_1, ⋯⟩ | false |
CategoryTheory.Limits.Cofork.ofCocone | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} →
CategoryTheory.Limits.Cocone F →
CategoryTheory.Limits.Cofork (F.map CategoryTheory.Limits.WalkingParallelPairHom.left)
(F.map CategoryTheory.Limits.Walking... | true |
CategoryTheory.Ind.yoneda.fullyFaithful | Mathlib.CategoryTheory.Limits.Indization.Category | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Ind.yoneda.FullyFaithful | true |
UniformConvergenceCLM.sub_apply | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologi... | true |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.insertManyIfNewUnit._proof_2 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {ρ : Type u_2} [inst : ForIn Id ρ α] (m : Std.DHashMap α fun x => Unit)
(l : ρ), (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit ⟨m.inner, ⋯⟩ l)).WF | false |
Std.Sat.AIG.toGraphviz.toGraphvizString.match_1 | Std.Sat.AIG.Basic | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(x : Std.Sat.AIG.Decl α) →
(Unit → motive Std.Sat.AIG.Decl.false) →
((i : α) → motive (Std.Sat.AIG.Decl.atom i)) →
((l r : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate l r)) → motive x | false |
Int.dvd_zero._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ (n : ℤ), (n ∣ 0) = True | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF._proof_23 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (state : Std.Sat.AIG.toCNF.State✝ aig),
(Std.Sat.AIG.toCNF.Cache.marks✝ (Std.Sat.AIG.toCNF.State.cache✝ state)).size = aig.decls.size →
¬upper < (Std.Sat.AIG.toCNF.Cache.marks✝¹ (Std.Sat.AIG.toCNF.State.cache✝¹ state)).size → False | false |
ProbabilityTheory.IsMeasurableRatCDF.measurable_stieltjesFunction | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {f : α → ℚ → ℝ} [inst : MeasurableSpace α] (hf : ProbabilityTheory.IsMeasurableRatCDF f) (x : ℝ),
Measurable fun a => ↑(hf.stieltjesFunction a) x | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_insertIfNew._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 |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.fla | Init.Data.Format.Basic | Std.Format.WorkGroup✝ → Std.Format.FlattenAllowability | true |
String.codepointPosToUtf8PosFrom | Lean.Data.Lsp.Utf16 | String → String.Pos.Raw → ℕ → String.Pos.Raw | true |
CategoryTheory.Subfunctor.Subpresheaf.image_iSup | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} {ι : Type u_1}
(G : ι → CategoryTheory.Subfunctor F) (f : F ⟶ F'), (⨆ i, G i).image f = ⨆ i, (G i).image f | true |
Holor.cprankMax_1 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : Mul α] [inst_1 : AddMonoid α] {x : Holor α ds}, x.CPRankMax1 → Holor.CPRankMax 1 x | true |
Set.op_smul_set_mul_eq_mul_smul_set | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Semigroup α] (a : α) (s t : Set α), MulOpposite.op a • s * t = s * a • t | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.add_floor_neg_toNat_sum_eq | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι] (x : ι → ℕ),
x + ∑ i, (-IsProperLinearSet.floor✝ hs x i).toNat • ↑i =
IsProperLinearSet.fract✝ hs x + ∑ i, (IsProperLinearSet.floor✝¹ hs x i).toNat • ↑i | true |
Concept.ofIsIntent._proof_1 | Mathlib.Order.Concept | ∀ {α : Type u_1} {β : Type u_2} (r : α → β → Prop) (t : Set β), lowerPolar r t = lowerPolar r t | false |
CategoryTheory.IsFiltered.isConnected | Mathlib.CategoryTheory.Filtered.Connected | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C], CategoryTheory.IsConnected C | true |
isClopen_iInter | Mathlib.Topology.AlexandrovDiscrete | ∀ {ι : Sort u_1} {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {f : ι → Set α},
(∀ (i : ι), IsClopen (f i)) → IsClopen (⋂ i, f i) | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabOfNatCore._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
matrixEquivTensor._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_2) (R : Type u_1) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Fintype n] [inst_4 : DecidableEq n],
Function.RightInverse (MatrixEquivTensor.equiv n R A).invFun (MatrixEquivTensor.equiv n R A).toFun | false |
BitVec.mul_succ | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x * (y + 1#w) = x * y + x | true |
Equiv.IicFinsetSet._proof_2 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
Function.LeftInverse (fun b => ⟨↑b, ⋯⟩) fun b => ⟨↑b, ⋯⟩ | false |
nhdsWithin_extChartAt_target_eq_of_mem | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x : M} {z : E},
z ∈ (extChartAt I x)... | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.existsRatHint_of_ratHintsExhaustive._proof_1_33 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ (ratHints : Array (ℕ × Array ℕ)) (j : Fin (Array.map (fun x => x.1) ratHints).toList.length),
↑j < (Array.map (fun x => x.1) ratHints).size | false |
Std.Internal.List.getValue?_insertList | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.DistinctKeys toInsert →
Std.Internal.List.getValue? k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.getValue? k toInsert).or (Std.I... | true |
Algebra.norm | Mathlib.RingTheory.Norm.Defs | (R : Type u_1) → {S : Type u_2} → [inst : CommRing R] → [inst_1 : Ring S] → [Algebra R S] → S →* R | true |
HasFTaylorSeriesUpToOn.hasStrictFDerivAt | Mathlib.Analysis.Calculus.ContDiff.RCLike | ∀ {𝕂 : Type u_1} [inst : RCLike 𝕂] {E' : Type u_2} [inst_1 : NormedAddCommGroup E'] [inst_2 : NormedSpace 𝕂 E']
{F' : Type u_3} [inst_3 : NormedAddCommGroup F'] [inst_4 : NormedSpace 𝕂 F'] {n : WithTop ℕ∞} {s : Set E'}
{f : E' → F'} {x : E'} {p : E' → FormalMultilinearSeries 𝕂 E' F'},
HasFTaylorSeriesUpToOn ... | true |
LinearEquiv.multilinearMapCongrRight.congr_simp | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {R : Type uR} (S : Type uS) {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : (i : ι) → Module R (M₁ i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : Module R M₂] [inst_5 : Semiring S] [inst_6 : Module S M₂] [inst_7 : SMulCommClass R S ... | true |
RingCon.mk'._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (c : RingCon R), ↑1 = ↑1 | false |
RingEquiv.piMulOpposite._proof_4 | Mathlib.Algebra.Ring.Equiv | ∀ {ι : Type u_1} (S : ι → Type u_2) [inst : (i : ι) → NonUnitalNonAssocSemiring (S i)] (x x_1 : ((i : ι) → S i)ᵐᵒᵖ),
(fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i)) = fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i) | false |
CategoryTheory.Dial.tensorUnit_rel | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C],
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Dial C)).rel = ⊤ | true |
Lean.Lsp.InlayHintParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.InlayHintParams} → t = t' → Lean.Lsp.InlayHintParams.noConfusionType P t t' | false |
NNDist.mk.noConfusion | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u_3} →
{P : Sort u} →
{nndist nndist' : α → α → NNReal} → { nndist := nndist } = { nndist := nndist' } → (nndist ≍ nndist' → P) → P | false |
Tropical.instAddCommSemigroupTropical._proof_2 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] (x x_1 : Tropical R), x + x_1 = x_1 + x | false |
threeGPFree_smul_set₀ | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} [inst : CommMonoidWithZero α] [IsCancelMulZero α] [NoZeroDivisors α] {s : Set α} {a : α},
a ≠ 0 → (ThreeGPFree (a • s) ↔ ThreeGPFree s) | true |
ProbabilityTheory.Kernel.withDensity_zero' | Mathlib.Probability.Kernel.WithDensity | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β)
[inst : ProbabilityTheory.IsSFiniteKernel κ], (κ.withDensity fun x x_1 => 0) = 0 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.