name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ContinuousMap.liftCover' | Mathlib.Topology.ContinuousMap.Basic | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(A : Set (Set α)) →
(F : (s : Set α) → s ∈ A → C(↑s, β)) →
(∀ (s : Set α) (hs : s ∈ A) (t : Set α) (ht : t ∈ A) (x : α) (hxi : x ∈ s) (hxj : x ∈ t),
(F s hs) ⟨x, hxi⟩ = (F t ht) ⟨x, hxj⟩) →
(∀ (x : α), ∃ i ∈ A, i ∈ nhds x) → C(α, β) | true |
FreeGroup.of_ne_one | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (a : α), FreeGroup.of a ≠ 1 | true |
_private.Mathlib.Order.Interval.Set.Pi.0.Set.pi_univ_Ioc_update_left._simp_1_1 | Mathlib.Order.Interval.Set.Pi | ∀ {α : Type u} (a b c : Set α), a ∩ (b ∩ c) = a ∩ b ∩ c | false |
EuclideanGeometry.Sphere.IsDiameter.wbtw | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
s.IsDiameter p₁ p₂ → Wbtw ℝ p₁ s.center p₂ | true |
_private.Plausible.Sampleable.0.Plausible.mkGenerator.match_1 | Plausible.Sampleable | (motive : Lean.Level → Sort u_1) →
(u : Lean.Level) → ((u : Lean.Level) → motive u.succ) → ((x : Lean.Level) → motive x) → motive u | false |
Array.count_empty | Init.Data.Array.Count | ∀ {α : Type u_1} [inst : BEq α] {a : α}, Array.count a #[] = 0 | true |
HomotopicalAlgebra.ModelCategory.categoryWithCofibrations._autoParam | Mathlib.AlgebraicTopology.ModelCategory.Basic | Lean.Syntax | false |
AddHom.noncommCoprod._proof_1 | Mathlib.GroupTheory.NoncommCoprod | ∀ {M : Type u_2} {N : Type u_3} {P : Type u_1} [inst : Add M] [inst_1 : Add N] [inst_2 : AddSemigroup P] (f : M →ₙ+ P)
(g : N →ₙ+ P),
(∀ (m : M) (n : N), AddCommute (f m) (g n)) →
∀ (mn mn' : M × N), f (mn + mn').1 + g (mn + mn').2 = f mn.1 + g mn.2 + (f mn'.1 + g mn'.2) | false |
Polynomial.rootsExpandPowEquivRoots_apply | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] (p : ℕ) [inst_2 : ExpChar R p] (f : Polynomial R)
[inst_3 : DecidableEq R] [inst_4 : PerfectRing R p] (n : ℕ) (x : ↥((Polynomial.expand R (p ^ n)) f).roots.toFinset),
↑((Polynomial.rootsExpandPowEquivRoots p f n) x) = ↑x ^ p ^ n | true |
CategoryTheory.ComposableArrows.Precomp.obj.eq_1 | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) (X : C)
(isLt : 0 < n + 1 + 1), CategoryTheory.ComposableArrows.Precomp.obj F X ⟨0, isLt⟩ = X | true |
Subsemiring.centralizer_univ | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R], Subsemiring.centralizer Set.univ = Subsemiring.center R | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_381 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] 1] + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[List.idxOfNth w_1 [g a, g (g a)] 1] <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.rewrite?.diagnoseWhenNoIndex | Lean.Meta.Tactic.Simp.Rewrite | Lean.Expr → Lean.Meta.SimpTheoremTree → Lean.Meta.SimpTheorem → Lean.Meta.SimpM Unit | true |
EReal.mul_div_cancel | Mathlib.Data.EReal.Inv | ∀ {a b : EReal}, b ≠ ⊥ → b ≠ ⊤ → b ≠ 0 → b * (a / b) = a | true |
Function.infinite_of_left | Mathlib.Data.Fintype.Prod | ∀ {ι : Sort u_4} {π : Type u_5} [Nontrivial π] [Infinite ι], Infinite (ι → π) | true |
Submodule.toConvexCone_top | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M], ⊤.toConvexCone = ⊤ | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.insertUnitInvariant_insertUnit._proof_1_8 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (units : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment),
assignments.size = n →
∀ (foundContradiction : Bool) (l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (i : Fin n),
¬Std.Tactic.BVDecide.LRAT.Internal.Assignment.hasAssignment l.2 assignments[↑l.1]! = true →
↑i = ↑l.1 →
↑l.1 < (assignments.modify (↑l.1) (Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment l.2)).size | false |
WithConv._sizeOf_inst | Mathlib.Algebra.WithConv | (A : Sort u_1) → [SizeOf A] → SizeOf (WithConv A) | false |
Real.arsinh_sinh | Mathlib.Analysis.SpecialFunctions.Arsinh | ∀ (x : ℝ), Real.arsinh (Real.sinh x) = x | true |
OrderBot.recOn | Mathlib.Order.BoundedOrder.Basic | {α : Type u} →
[inst : LE α] →
{motive : OrderBot α → Sort u_1} →
(t : OrderBot α) →
([toBot : Bot α] → (bot_le : ∀ (a : α), ⊥ ≤ a) → motive { toBot := toBot, bot_le := bot_le }) → motive t | false |
mul_lt_of_lt_one_left | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Zero α] {a b : α} [inst_2 : Preorder α] [MulPosStrictMono α],
0 < b → a < 1 → a * b < b | true |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.iterate_derivative_prod_X_sub_C._proof_1_14 | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u_1} {S : Finset R} (k : ℕ),
k + 1 ≤ S.card → ∀ T ∈ Finset.powersetCard (S.card - (k + 1)) S, (S \ T).card = k + 1 | false |
IsFreeGroupoid.noConfusion | Mathlib.GroupTheory.FreeGroup.NielsenSchreier | {P : Sort u} →
{G : Type u_1} →
{inst : CategoryTheory.Groupoid G} →
{t : IsFreeGroupoid G} →
{G' : Type u_1} →
{inst' : CategoryTheory.Groupoid G'} →
{t' : IsFreeGroupoid G'} → G = G' → inst ≍ inst' → t ≍ t' → IsFreeGroupoid.noConfusionType P t t' | false |
_private.Mathlib.Probability.Distributions.Beta.0.ProbabilityTheory.lintegral_betaPDF_eq_one._simp_1_3 | Mathlib.Probability.Distributions.Beta | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
Batteries.RBNode.reverse_balRight | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α),
(l.balRight v r).reverse = r.reverse.balLeft v l.reverse | true |
Ordinal.monoid._proof_1 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (α : Type u_1) (r : α → α → Prop),
IsWellOrder α r → ∀ (β : Type u_1) (s : β → β → Prop), IsWellOrder β s → IsWellOrder (β × α) (Prod.Lex s r) | false |
fderivWithin_ccosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E},
DifferentiableWithinAt ℂ f s x →
UniqueDiffWithinAt ℂ s x →
fderivWithin ℂ (fun x => Complex.cosh (f x)) s x = Complex.sinh (f x) • fderivWithin ℂ f s x | true |
Nat.exists_prime_lt_and_le_two_mul_eventually | Mathlib.NumberTheory.Bertrand | ∀ (n : ℕ), 512 ≤ n → ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n | true |
Std.DTreeMap.Raw.isSome_minKey?_eq_not_isEmpty | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → t.minKey?.isSome = !t.isEmpty | true |
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.recOn | Mathlib.CategoryTheory.Monoidal.Action.Basic | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategoryStruct C] →
{motive : CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct C D → Sort u} →
(t : CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct C D) →
((actionObj : C → D → D) →
(actionHomLeft : {c c' : C} → (c ⟶ c') → (d : D) → actionObj c d ⟶ actionObj c' d) →
(actionHomRight : (c : C) → {d d' : D} → (d ⟶ d') → (actionObj c d ⟶ actionObj c d')) →
(actionHom : {c c' : C} → {d d' : D} → (c ⟶ c') → (d ⟶ d') → (actionObj c d ⟶ actionObj c' d')) →
(actionAssocIso :
(c c' : C) →
(d : D) →
actionObj (CategoryTheory.MonoidalCategoryStruct.tensorObj c c') d ≅
actionObj c (actionObj c' d)) →
(actionUnitIso :
(d : D) → actionObj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) d ≅ d) →
motive
{ actionObj := actionObj, actionHomLeft := actionHomLeft,
actionHomRight := actionHomRight, actionHom := actionHom,
actionAssocIso := actionAssocIso, actionUnitIso := actionUnitIso }) →
motive t | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt.0.Lean.Meta.Grind.Arith.Cutsat.getToIntId?.toIntInterval? | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Option Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval) | true |
AddSubsemigroup.coe_copy | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M] {S : AddSubsemigroup M} {s : Set M} (hs : s = ↑S), ↑(S.copy s hs) = s | true |
Lean.Lsp.ChangeAnnotation.mk._flat_ctor | Lean.Data.Lsp.Basic | String → Bool → Option String → Lean.Lsp.ChangeAnnotation | false |
AlgebraicGeometry.IsLocallyArtinian.mk | Mathlib.AlgebraicGeometry.Artinian | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (∀ (U : ↑X.affineOpens), IsArtinianRing ↑(X.presheaf.obj (Opposite.op ↑U)))
AlgebraicGeometry.IsLocallyArtinian.isArtinianRing_presheaf_obj._autoParam →
AlgebraicGeometry.IsLocallyArtinian X | true |
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator | Lean.PrettyPrinter.Delaborator.SubExpr | Type | true |
bddAbove_Ioc._simp_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, BddAbove (Set.Ioc a b) = True | false |
Real.iInter_Iic_rat | Mathlib.Data.Real.Archimedean | ⋂ r, Set.Iic ↑r = ∅ | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.insertUnitInvariant_insertUnit._proof_1_17 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (units : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) (foundContradiction : Bool)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
Std.Tactic.BVDecide.LRAT.Internal.Assignment.hasAssignment l.2 assignments[↑l.1]! = true →
∀
(k :
Fin
(if Std.Tactic.BVDecide.LRAT.Internal.Assignment.hasAssignment l.2 assignments[↑l.1]! = true then
(units, assignments, foundContradiction)
else
(units.push (l.1, l.2),
assignments.modify (↑l.1) (Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment l.2),
foundContradiction ||
assignments[↑l.1]! != Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned)).1.size),
↑k < units.size | false |
iSup_succ | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrderBot α] [inst_1 : SuccOrder α] (x : α), ⨆ a, Order.succ ↑a = x | true |
CategoryTheory.Limits.Wedge.ext._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)}
{W₁ W₂ : CategoryTheory.Limits.Wedge F} (e : W₁.pt ≅ W₂.pt),
(∀ (j : J),
CategoryTheory.Limits.Multifork.ι W₁ j =
CategoryTheory.CategoryStruct.comp e.hom (CategoryTheory.Limits.Multifork.ι W₂ j)) →
∀ (f : (CategoryTheory.Limits.multicospanShapeEnd J).R),
W₁.π.app (CategoryTheory.Limits.WalkingMulticospan.right f) =
CategoryTheory.CategoryStruct.comp e.hom (W₂.π.app (CategoryTheory.Limits.WalkingMulticospan.right f)) | false |
TopologicalSpace.IsTopologicalBasis.nonemptyCompacts | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {B : Set (Set α)},
TopologicalSpace.IsTopologicalBasis B →
TopologicalSpace.IsTopologicalBasis
((fun u => {K | ↑K ⊆ ⋃₀ u ∧ ∀ U ∈ u, (↑K ∩ U).Nonempty}) '' {u | u.Finite ∧ u.Nonempty ∧ u ⊆ B}) | true |
_private.Mathlib.RingTheory.MvPolynomial.Ideal.0.MonomialOrder.span_leadingTerm_eq_span_monomial'._simp_1_1 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ (p : Prop), (¬p ∨ p) = True | false |
BoundedLatticeHom.toFun_eq_coe | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder α]
[inst_3 : BoundedOrder β] (f : BoundedLatticeHom α β), f.toFun = ⇑f | true |
CategoryTheory.GradedObject.mapTrifunctorObj_map_app | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7}
(X₁ : CategoryTheory.GradedObject I₁ C₁) (I₂ : Type u_8) (I₃ : Type u_9) {X₂ Y₂ : CategoryTheory.GradedObject I₂ C₂}
(φ : X₂ ⟶ Y₂) (X₃ : CategoryTheory.GradedObject I₃ C₃) (x : I₁ × I₂ × I₃),
((CategoryTheory.GradedObject.mapTrifunctorObj F X₁ I₂ I₃).map φ).app X₃ x =
((F.obj (X₁ x.1)).map (φ x.2.1)).app (X₃ x.2.2) | true |
Lean.EnvironmentHeader.casesOn | Lean.Environment | {motive : Lean.EnvironmentHeader → Sort u} →
(t : Lean.EnvironmentHeader) →
((trustLevel : UInt32) →
(mainModule : Lean.Name) →
(isModule : Bool) →
(imports : Array Lean.Import) →
(regions : Array Lean.CompactedRegion) →
(modules : Array Lean.EffectiveImport) →
(moduleName2Idx : Std.HashMap Lean.Name Lean.ModuleIdx) →
(importAllModules : Array Lean.EffectiveImport) →
(moduleData : Array Lean.ModuleData) →
motive
{ trustLevel := trustLevel, mainModule := mainModule, isModule := isModule,
imports := imports, regions := regions, modules := modules,
moduleName2Idx := moduleName2Idx, importAllModules := importAllModules,
moduleData := moduleData }) →
motive t | false |
MulRingNorm.mulRingNormEquivAbsoluteValue._proof_4 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_1} [inst : Ring R] (N : MulRingNorm R) (a : R), 0 ≤ N a | false |
LinOrd.Hom.noConfusionType | Mathlib.Order.Category.LinOrd | Sort u_1 → {X Y : LinOrd} → X.Hom Y → {X' Y' : LinOrd} → X'.Hom Y' → Sort u_1 | false |
Lean.ppExt | Lean.Util.PPExt | Lean.EnvExtension Lean.PPFns | true |
Std.DTreeMap.Raw.getKey_map | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} {γ : α → Type w}
[inst : Std.TransCmp cmp] {f : (a : α) → β a → γ a} {k : α} {h' : k ∈ Std.DTreeMap.Raw.map f t} (h : t.WF),
(Std.DTreeMap.Raw.map f t).getKey k h' = t.getKey k ⋯ | true |
CategoryTheory.MorphismProperty.IsStableUnderTransfiniteCompositionOfShape.recOn | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{motive : W.IsStableUnderTransfiniteCompositionOfShape J → Sort u_1} →
(t : W.IsStableUnderTransfiniteCompositionOfShape J) →
((le : W.transfiniteCompositionsOfShape J ≤ W) → motive ⋯) → motive t | false |
Std.ExtHashSet.insertMany_ind | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {ρ : Type v} [inst : ForIn Id ρ α] [inst_1 : EquivBEq α]
[inst_2 : LawfulHashable α] {motive : Std.ExtHashSet α → Prop} (m : Std.ExtHashSet α) {l : ρ},
motive m → (∀ (m : Std.ExtHashSet α) (a : α), motive m → motive (m.insert a)) → motive (m.insertMany l) | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedAction._proof_2 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_4) (D : Type u_2) [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (x : C) (X : D),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight x (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj x X) | false |
OpenPartialHomeomorph.isOpen_extend_source | 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]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H}, IsOpen (f.extend I).source | true |
MeasureTheory.instFunLikeAddContentSet | Mathlib.MeasureTheory.Measure.AddContent | {α : Type u_1} →
{C : Set (Set α)} → {G : Type u_2} → [inst : AddCommMonoid G] → FunLike (MeasureTheory.AddContent G C) (Set α) G | true |
Lean.Data.AC.ContextInformation.rec | Init.Data.AC | {α : Sort u} →
{motive : Lean.Data.AC.ContextInformation α → Sort u_1} →
((isNeutral : α → ℕ → Bool) →
(isComm isIdem : α → Bool) → motive { isNeutral := isNeutral, isComm := isComm, isIdem := isIdem }) →
(t : Lean.Data.AC.ContextInformation α) → motive t | false |
NonemptyFinLinOrd.recOn | Mathlib.Order.Category.NonemptyFinLinOrd | {motive : NonemptyFinLinOrd → Sort u} →
(t : NonemptyFinLinOrd) →
((toLinOrd : LinOrd) →
[nonempty : Nonempty ↑toLinOrd] →
[fintype : Fintype ↑toLinOrd] → motive { toLinOrd := toLinOrd, nonempty := nonempty, fintype := fintype }) →
motive t | false |
EStateM.Backtrackable.save | Init.Prelude | {δ : outParam (Type u)} → {σ : Type u} → [self : EStateM.Backtrackable δ σ] → σ → δ | true |
Lean.Parser.Term.waitIfContainsMVar._regBuiltin.Lean.Parser.Term.waitIfContainsMVar_1 | Lean.Parser.Term | IO Unit | false |
_private.Mathlib.MeasureTheory.Integral.CircleAverage.0.Real.circleAverage_mono._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleAverage | (0 < Real.pi) = True | false |
Lean.EnvExtension.setState | Lean.Environment | {σ : Type} →
(ext : Lean.EnvExtension σ) →
Lean.Environment → σ → optParam Lean.EnvExtension.AsyncMode ext.asyncMode → Lean.Environment | true |
_private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.evalNatCast.match_3 | Mathlib.Tactic.Positivity.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(_pα : Q(PartialOrder «$α»)) →
(_i1 : Q(AddMonoidWithOne «$α»)) →
(_x_1 : Lean.Level) →
(_x_2 : Q(Sort _x_1)) →
(motive : Q(«$_x_2») → Sort u_1) →
(__discr : Q(«$_x_2»)) → ((_i2 : Q(AddLeftMono «$α»)) → motive _i2) → motive __discr | false |
CategoryTheory.Limits.productIsProduct | Mathlib.CategoryTheory.Limits.Shapes.Products | {β : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(f : β → C) →
[inst_1 : CategoryTheory.Limits.HasProduct f] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fan.mk (∏ᶜ f) (CategoryTheory.Limits.Pi.π f)) | true |
Lean.Server.mkPublishDiagnosticsNotification | Lean.Server.Utils | Lean.Server.DocumentMeta → Array Lean.Lsp.Diagnostic → Lean.JsonRpc.Notification Lean.Lsp.PublishDiagnosticsParams | true |
FreeAddMagma.lift_of | Mathlib.Algebra.Free | ∀ {α : Type u} {β : Type v} [inst : Add β] (f : α → β) (x : α), (FreeAddMagma.lift f) (FreeAddMagma.of x) = f x | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_30 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l' r' d : Std.DTreeMap.Internal.Impl α β),
r'.size ≤ d.size → d.size ≤ r'.size + 1 → ¬l'.size + 1 + d.size ≤ l'.size + 1 + r'.size + 1 → False | false |
Lean.Lsp.ApplyWorkspaceEditParams.mk._flat_ctor | Lean.Data.Lsp.Basic | Option String → Lean.Lsp.WorkspaceEdit → Lean.Lsp.ApplyWorkspaceEditParams | false |
BitVec.sdiv_eq.match_1 | Init.Data.BitVec.Lemmas | (motive : Bool → Bool → Sort u_1) →
(x x_1 : Bool) →
(Unit → motive false false) →
(Unit → motive false true) → (Unit → motive true false) → (Unit → motive true true) → motive x x_1 | false |
Std.Internal.Parsec.String.ws | Std.Internal.Parsec.String | Std.Internal.Parsec.String.Parser Unit | true |
Lean.Elab.Term.elabByTactic | Lean.Elab.BuiltinTerm | Lean.Elab.Term.TermElab | true |
ContinuousLinearMap.instStarModuleId | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E], StarModule 𝕜 (E →L[𝕜] E) | true |
CategoryTheory.WithTerminal.equivComma_inverse_obj_obj | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(c : CategoryTheory.Comma (CategoryTheory.Functor.id (CategoryTheory.Functor C D)) (CategoryTheory.Functor.const C))
(X : CategoryTheory.WithTerminal C),
(CategoryTheory.WithTerminal.equivComma.inverse.obj c).obj X =
match X with
| CategoryTheory.WithTerminal.of x => c.left.obj x
| CategoryTheory.WithTerminal.star => c.right | true |
not_irreducible_expand | Mathlib.FieldTheory.Perfect | ∀ (R : Type u_2) (p : ℕ) [inst : CommSemiring R] [Fact (Nat.Prime p)] [CharP R p] [PerfectRing R p] (f : Polynomial R),
¬Irreducible ((Polynomial.expand R p) f) | true |
_private.Init.Data.String.Lemmas.Basic.0.String.Pos.startPos_le._simp_1_2 | Init.Data.String.Lemmas.Basic | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | false |
AffineSubspace.toAddTorsor | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | {k : Type u_1} →
{V : Type u_2} →
{P : Type u_3} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module k V] →
[inst_3 : AddTorsor V P] → (s : AffineSubspace k P) → [Nonempty ↥s] → AddTorsor ↥s.direction ↥s | true |
Primrec.nat_omega_rec | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable σ]
(f : α → β → σ) {m : α → β → ℕ} {l : α → β → List β} {g : α → β × List σ → Option σ},
Primrec₂ m →
Primrec₂ l →
Primrec₂ g →
(∀ (a : α) (b b' : β), b' ∈ l a b → m a b' < m a b) →
(∀ (a : α) (b : β), g a (b, List.map (f a) (l a b)) = some (f a b)) → Primrec₂ f | true |
Turing.TM2Computable.noConfusion | Mathlib.Computability.TuringMachine.Computable | {P : Sort u} →
{α β αΓ βΓ : Type} →
{ea : α → List αΓ} →
{eb : β → List βΓ} →
{f : α → β} →
{t : Turing.TM2Computable ea eb f} →
{α' β' αΓ' βΓ' : Type} →
{ea' : α' → List αΓ'} →
{eb' : β' → List βΓ'} →
{f' : α' → β'} →
{t' : Turing.TM2Computable ea' eb' f'} →
α = α' →
β = β' →
αΓ = αΓ' →
βΓ = βΓ' →
ea ≍ ea' → eb ≍ eb' → f ≍ f' → t ≍ t' → Turing.TM2Computable.noConfusionType P t t' | false |
Algebra.TensorProduct.right_algebraMap_apply | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type uR} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (b : B), (algebraMap B (TensorProduct R A B)) b = 1 ⊗ₜ[R] b | true |
_private.Mathlib.Analysis.InnerProductSpace.PiL2.0.OrthonormalBasis.sum_sq_norm_inner_right._simp_1_1 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | false |
CentroidHom.instInhabited | Mathlib.Algebra.Ring.CentroidHom | (α : Type u_5) → [inst : NonUnitalNonAssocSemiring α] → Inhabited (CentroidHom α) | true |
_private.Mathlib.Logic.Equiv.Defs.0.Equiv.equivCongr_trans._proof_1_1 | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : Sort u_5} {γ : Sort u_2} {δ : Sort u_3} {ε : Sort u_6} {ζ : Sort u_4} (ab : α ≃ β) (de : δ ≃ ε)
(bc : β ≃ γ) (ef : ε ≃ ζ), (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef) | false |
DifferentiableAt.continuousMultilinearMapCompContinuousLinearMap | Mathlib.Analysis.Calculus.FDeriv.ContinuousMultilinearMap | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : Type u_3} {F : ι → Type u_4} {G : ι → Type u_5} {H : Type u_6}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : (i : ι) → NormedAddCommGroup (F i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F i)]
[inst_5 : (i : ι) → NormedAddCommGroup (G i)] [inst_6 : (i : ι) → NormedSpace 𝕜 (G i)] [inst_7 : NormedAddCommGroup H]
[inst_8 : NormedSpace 𝕜 H] {f : E → ContinuousMultilinearMap 𝕜 G H} {g : (i : ι) → E → F i →L[𝕜] G i} {x : E}
[Finite ι],
DifferentiableAt 𝕜 f x →
(∀ (i : ι), DifferentiableAt 𝕜 (g i) x) →
DifferentiableAt 𝕜 (fun x => (f x).compContinuousLinearMap fun x_1 => g x_1 x) x | true |
OrthonormalBasis.repr_reindex | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {ι' : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : Fintype ι'] (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι')
(x : E) (i' : ι'), ((b.reindex e).repr x).ofLp i' = (b.repr x).ofLp (e.symm i') | true |
CategoryTheory.PreOneHypercover.Hom.w₁₂._autoParam | Mathlib.CategoryTheory.Sites.Hypercover.One | Lean.Syntax | false |
Lean.MessageData.Exprs.noConfusionType | Mathlib.Lean.MessageData.ForExprs | Sort u → Lean.MessageData.Exprs → Lean.MessageData.Exprs → Sort u | false |
curveIntegrable_neg_iff | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {a b : E} {ω : E → E →L[𝕜] F}
{γ : Path a b}, CurveIntegrable (-ω) γ ↔ CurveIntegrable ω γ | true |
ENNReal.div_eq_one_iff | Mathlib.Data.ENNReal.Inv | ∀ {a b : ENNReal}, b ≠ 0 → b ≠ ⊤ → (a / b = 1 ↔ a = b) | true |
Submonoid.multiset_noncommProd_mem | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) (m : Multiset M) (comm : {x | x ∈ m}.Pairwise Commute),
(∀ x ∈ m, x ∈ S) → m.noncommProd comm ∈ S | true |
Nat.nth_mem_of_ne_zero | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} {n : ℕ}, Nat.nth p n ≠ 0 → p (Nat.nth p n) | true |
_private.Mathlib.Topology.Algebra.Module.LinearMap.0.ContinuousLinearMap.instNontrivialId.match_1 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {M₁ : Type u_1} [inst : AddCommMonoid M₁] (motive : (∃ y, y ≠ 0) → Prop) (x : ∃ y, y ≠ 0),
(∀ (x : M₁) (hx : x ≠ 0), motive ⋯) → motive x | false |
CategoryTheory.Reflective.mk | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
[toFull : R.Full] →
[toFaithful : R.Faithful] → (L : CategoryTheory.Functor C D) → (L ⊣ R) → CategoryTheory.Reflective R | true |
IsCoinitial.eq_1 | Mathlib.Order.Bounds.Defs | ∀ {α : Type u_1} [inst : LE α] (s : Set α), IsCoinitial s = ∀ (x : α), ∃ y ∈ s, y ≤ x | true |
_private.Lean.Meta.DiscrTree.Main.0.Lean.Meta.DiscrTree.getKeyArgs._sparseCasesOn_3 | Lean.Meta.DiscrTree.Main | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 2710 t.ctorIdx → motive t) → motive t | false |
Lean.Server.Test.Runner.Client.Hyp.isInserted? | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.Hyp → Option Bool | true |
FrameHom | Mathlib.Order.Hom.CompleteLattice | (α : Type u_8) → (β : Type u_9) → [CompleteLattice α] → [CompleteLattice β] → Type (max u_8 u_9) | true |
CategoryTheory.InjectiveResolution.ι_f_zero_comp_complex_d | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z),
CategoryTheory.CategoryStruct.comp (I.ι.f 0) (I.cocomplex.d 0 1) = 0 | true |
NormedDivisionRing.ratCast._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_5} → (ℕ → α) → (ℤ → α) → (α → α → α) → ℚ → α | false |
Std.DTreeMap.Internal.Impl.balanceₘ.fun_cases_unfolding | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k)
(motive : Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Prop),
(∀ (l r : Std.DTreeMap.Internal.Impl α β),
l.size + r.size ≤ 1 → motive l r (Std.DTreeMap.Internal.Impl.bin k v l r)) →
(∀ (l : Std.DTreeMap.Internal.Impl α β) (size : ℕ) (rk : α) (rv : β rk) (rl rr : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size rk rv rl rr).size > Std.DTreeMap.Internal.delta * l.size →
¬l.size + (Std.DTreeMap.Internal.Impl.inner size rk rv rl rr).size ≤ 1 →
(Std.DTreeMap.Internal.Impl.inner size rk rv rl rr).size > Std.DTreeMap.Internal.delta * l.size →
motive l (Std.DTreeMap.Internal.Impl.inner size rk rv rl rr)
(Std.DTreeMap.Internal.Impl.rotateL k v l rk rv rl rr)) →
(∀ (r : Std.DTreeMap.Internal.Impl α β) (size : ℕ) (lk : α) (lv : β lk) (ll lr : Std.DTreeMap.Internal.Impl α β),
¬r.size > Std.DTreeMap.Internal.delta * (Std.DTreeMap.Internal.Impl.inner size lk lv ll lr).size →
(Std.DTreeMap.Internal.Impl.inner size lk lv ll lr).size > Std.DTreeMap.Internal.delta * r.size →
¬(Std.DTreeMap.Internal.Impl.inner size lk lv ll lr).size + r.size ≤ 1 →
¬r.size > Std.DTreeMap.Internal.delta * (Std.DTreeMap.Internal.Impl.inner size lk lv ll lr).size →
(Std.DTreeMap.Internal.Impl.inner size lk lv ll lr).size > Std.DTreeMap.Internal.delta * r.size →
motive (Std.DTreeMap.Internal.Impl.inner size lk lv ll lr) r
(Std.DTreeMap.Internal.Impl.rotateR k v lk lv ll lr r)) →
(∀ (l r : Std.DTreeMap.Internal.Impl α β),
¬l.size + r.size ≤ 1 →
¬r.size > Std.DTreeMap.Internal.delta * l.size →
¬l.size > Std.DTreeMap.Internal.delta * r.size → motive l r (Std.DTreeMap.Internal.Impl.bin k v l r)) →
∀ (l r : Std.DTreeMap.Internal.Impl α β), motive l r (Std.DTreeMap.Internal.Impl.balanceₘ k v l r) | true |
LieAlgebra.IsExtension.exact | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_1} {N : Type u_2} {L : Type u_3} {M : Type u_4} {inst : CommRing R} {inst_1 : LieRing L}
{inst_2 : LieAlgebra R L} {inst_3 : LieRing N} {inst_4 : LieAlgebra R N} {inst_5 : LieRing M}
{inst_6 : LieAlgebra R M} {i : N →ₗ⁅R⁆ L} {p : L →ₗ⁅R⁆ M} [self : LieAlgebra.IsExtension i p],
i.range = LieIdeal.toLieSubalgebra R L p.ker | true |
MonotoneOn._to_dual_cast_4 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β) (s : Set α),
MonotoneOn f s = ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → b ≤ a → f b ≤ f a | false |
CategoryTheory.Lax.LaxTrans.StrongCore.naturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{η : F ⟶ G} →
CategoryTheory.Lax.LaxTrans.StrongCore η →
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (η.app a) (G.map f) ≅
CategoryTheory.CategoryStruct.comp (F.map f) (η.app b) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.