name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
LipschitzWith.mapsTo_closedBall | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ (x : α) (r : ℝ), Set.MapsTo f (Metric.closedBall x r) (Metric.closedBall (f x) (↑K * r)) | true |
Nat.Coprime.sum_divisors_mul | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {m n : ℕ}, m.Coprime n → ∑ d ∈ (m * n).divisors, d = (∑ d ∈ m.divisors, d) * ∑ d ∈ n.divisors, d | true |
Real.isTheta_exp_comp_exp_comp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} {l : Filter α} {f g : α → ℝ},
((fun x => Real.exp (f x)) =Θ[l] fun x => Real.exp (g x)) ↔
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l fun x => |f x - g x| | true |
Std.ExtDTreeMap.union_insert_right_eq_insert_union | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{p : (a : α) × β a}, t₁ ∪ t₂.insert p.fst p.snd = (t₁ ∪ t₂).insert p.fst p.snd | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁.instMonoHomologyMapIntι._proof_2 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (n₁ : ℤ), n₁ - 1 = n₁ - 1 | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATChecker.0.Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go.match_3.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATChecker | ∀ {n : ℕ} (motive : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClauseAction n) → Sort u_1)
(h_1 : Unit → motive none)
(h_2 : (id : ℕ) → (rupHints : Array ℕ) → motive (some (Std.Tactic.BVDecide.LRAT.Action.addEmpty id rupHints)))
(h_3 :
(id : ℕ) →
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClaus... | true |
Vector.insertIdx_eraseIdx._proof_3 | Init.Data.Vector.InsertIdx | ∀ {n i : ℕ}, i < n → i + 1 < n + 1 | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] {n s : ℕ} {h : n < (List.idxsOf x [] s).length},
(List.idxsOf x [] s)[n] - s + 1 ≤ [].length → (List.idxsOf x [] s)[n] - s < [].length | false |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toStalkₗ'.eq_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R M : Type u) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top R)),
AlgebraicGeometry.StructureSheaf.toStalkₗ'✝ R M x =
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (AlgebraicGeometry.StructureSheaf.toOpenₗ R M ⊤))
((AlgebraicGeometry... | true |
List.length_erase | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {a : α} {l : List α},
(l.erase a).length = if a ∈ l then l.length - 1 else l.length | true |
Nat.Partition.recOn | Mathlib.Combinatorics.Enumerative.Partition.Basic | {n : ℕ} →
{motive : n.Partition → Sort u} →
(t : n.Partition) →
((parts : Multiset ℕ) →
(parts_pos : ∀ {i : ℕ}, i ∈ parts → 0 < i) →
(parts_sum : parts.sum = n) → motive { parts := parts, parts_pos := parts_pos, parts_sum := parts_sum }) →
motive t | false |
Mathlib.Meta.FunProp.instInhabitedFunPropDecl | Mathlib.Tactic.FunProp.Decl | Inhabited Mathlib.Meta.FunProp.FunPropDecl | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis.0.Tactic.ComputeAsymptotics.WellFormedBasis.eventually_pos._simp_1_2 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {α : Type u} {R : α → α → Prop} {a : α} {l : List α},
List.Pairwise R (a :: l) = ((∀ a' ∈ l, R a a') ∧ List.Pairwise R l) | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_63 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (i j k : ℕ),
i < j → -1 * ↑j + 1 ≤ 0 → -1 * ↑i + 1 ≤ 0 → j - 1 + 1 ≤ k - 1 → k - 1 + 1 ≤ tail.length → i - 1 < tail.length | false |
AddAction.orbitRel | Mathlib.GroupTheory.GroupAction.Defs | (G : Type u_1) → (α : Type u_2) → [inst : AddGroup G] → [AddAction G α] → Setoid α | true |
CategoryTheory.MorphismProperty.IsStableUnderBraiding.braiding_hom_mem | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.MonoidalCategory C}
{inst_2 : CategoryTheory.BraidedCategory C} (P : CategoryTheory.MorphismProperty C) [self : P.IsStableUnderBraiding]
(c c' : C), P (β_ c c').hom | true |
Lean.Name.getRoot._sunfold | Init.Meta.Defs | Lean.Name → Lean.Name | false |
TypeVec.typevecCasesNil₂._proof_2 | Mathlib.Data.TypeVec | ∀ {β : TypeVec.Arrow Fin2.elim0 Fin2.elim0 → Sort u_1} (g : TypeVec.Arrow Fin2.elim0 Fin2.elim0),
g = TypeVec.nilFun → β g = β TypeVec.nilFun | false |
Std.TreeMap.mem_union_of_left | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t₁ → k ∈ t₁ ∪ t₂ | true |
SimpleGraph.Coloring.sumEquiv._proof_1 | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_1} {W : Type u_2} {γ : Type u_3} {G : SimpleGraph V} {H : SimpleGraph W} (c : (G ⊕g H).Coloring γ),
(fun p => p.1.sum p.2) ((fun c => (c.sumLeft, c.sumRight)) c) = c | false |
FixedDetMatrices.instSMulSpecialLinearGroupFixedDetMatrix | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | (n : Type u_1) →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
(R : Type u_2) → [inst_2 : CommRing R] → (m : R) → SMul (Matrix.SpecialLinearGroup n R) (FixedDetMatrix n R m) | true |
Lean.Meta.RecursorInfo | Lean.Meta.RecursorInfo | Type | true |
RootedTree.mk.noConfusion | Mathlib.Order.SuccPred.Tree | {P : Sort u} →
{α : Type u_2} →
{semilatticeInf : SemilatticeInf α} →
{orderBot : OrderBot α} →
{predOrder : PredOrder α} →
{isPredArchimedean : IsPredArchimedean α} →
{α' : Type u_2} →
{semilatticeInf' : SemilatticeInf α'} →
{orderBot' : OrderBot ... | false |
Hyperreal.instField._aux_70 | Mathlib.Analysis.Real.Hyperreal | ℚ → ℝ* → ℝ* | false |
Std.Roi.size.eq_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.Rxi.HasSize α] [inst_1 : Std.PRange.UpwardEnumerable α] (r : Std.Roi α),
r.size =
match Std.PRange.succ? r.lower with
| none => 0
| some lower => Std.Rxi.HasSize.size lower | true |
_private.Mathlib.Computability.RegularExpressions.0.RegularExpression.matches'.match_1.eq_4 | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (motive : RegularExpression α → Sort u_2) (P Q : RegularExpression α)
(h_1 : Unit → motive RegularExpression.zero) (h_2 : Unit → motive RegularExpression.epsilon)
(h_3 : (a : α) → motive (RegularExpression.char a)) (h_4 : (P Q : RegularExpression α) → motive (P.plus Q))
(h_5 : (P Q : RegularExpre... | true |
Nat.forall_lt_succ_left'._proof_2 | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, 0 < n + 1 | false |
AddRightCancelMonoid.add_eq_zero | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : AddRightCancelMonoid α] [Subsingleton (AddUnits α)] {a b : α}, a + b = 0 ↔ a = 0 ∧ b = 0 | true |
CategoryTheory.SingleFunctors.hom_ext_iff | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {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] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] {F G : CategoryTheory.SingleFunctors C D A} {f g : F ⟶ G},
f = g ↔ f.hom = g.hom | true |
CategoryTheory.Adjunction.ofNatIsoLeft | Mathlib.CategoryTheory.Adjunction.Basic | {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} → {H : CategoryTheory.Functor D C} → (F ⊣ H) → (F ≅ G) → (G ⊣ H) | true |
Lean.Elab.CommandContextInfo.ctorIdx | Lean.Elab.InfoTree.Types | Lean.Elab.CommandContextInfo → ℕ | false |
Topology.«_aux_Mathlib_Topology_Defs_Filter___macroRules_Topology_term𝓝ˢ_1» | Mathlib.Topology.Defs.Filter | Lean.Macro | false |
SeparationQuotient.instNonUnitalRing._proof_6 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonUnitalRing R] [IsTopologicalRing R], ContinuousConstSMul ℤ R | false |
TopologicalSpace.secondCountableTopology_iInf | Mathlib.Topology.Bases | ∀ {α : Type u_1} {ι : Sort u_2} [Countable ι] {t : ι → TopologicalSpace α},
(∀ (i : ι), SecondCountableTopology α) → SecondCountableTopology α | true |
ENNReal.toReal_lt_toReal | Mathlib.Data.ENNReal.Real | ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → (a.toReal < b.toReal ↔ a < b) | true |
Finsupp.lcoeFun._proof_2 | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : R) (y : α →₀ M), ⇑(x • y) = (RingHom.id R) x • ⇑y | false |
Set.nontrivial_of_einfsep_ne_top | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Set α}, s.einfsep ≠ ⊤ → s.Nontrivial | true |
Lean.SMap.rec | Lean.Data.SMap | {α : Type u} →
{β : Type v} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Lean.SMap α β → Sort u_1} →
((stage₁ : Bool) →
(map₁ : Std.HashMap α β) →
(map₂ : Lean.PHashMap α β) → motive { stage₁ := stage₁, map₁ := map₁, map₂ := map₂ }) →
(t : ... | false |
EuclideanGeometry.instNonemptySphere | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} [inst : MetricSpace P] [Nonempty P], Nonempty (EuclideanGeometry.Sphere P) | true |
Lean.Meta.eqnThmSuffixBase | Lean.Meta.Eqns | String | true |
Matrix.vec_mul_eq_vecMul | Mathlib.LinearAlgebra.Matrix.Vec | ∀ {m : Type u_1} {n : Type u_2} {p : Type u_4} {R : Type u_3} [inst : Semiring R] [inst_1 : Fintype m]
[inst_2 : Fintype n] [inst_3 : DecidableEq m] (A : Matrix m n R) (B : Matrix n p R),
(A * B).vec = Matrix.vecMul A.vec (Matrix.kroneckerMap (fun x1 x2 => x1 * x2) B 1) | true |
LeanSearchClient.SearchResult.mk._flat_ctor | LeanSearchClient.Syntax | String → Option String → Option String → Option String → Option String → LeanSearchClient.SearchResult | false |
LocallyConstant.ext | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] ⦃f g : LocallyConstant X Y⦄, (∀ (x : X), f x = g x) → f = g | true |
_private.Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors.0.MonoidAlgebra.instIsLeftCancelMulZeroOfIsCancelAddOfUniqueProds._simp_2 | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M}, (f.support = ∅) = (f = 0) | false |
_private.Lean.Elab.Tactic.Rewrite.0.Lean.Elab.Tactic.withRWRulesSeq.match_3 | Lean.Elab.Tactic.Rewrite | (motive : Option (Array Lean.Name) → Sort u_1) →
(__discr : Option (Array Lean.Name)) →
((eqThms : Array Lean.Name) → motive (some eqThms)) → ((x : Option (Array Lean.Name)) → motive x) → motive __discr | false |
CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj._proof_1 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_5} {C₂ : Type u_7} {C₃ : Type u_9} {C₄ : Type u_3} [inst : CategoryTheory.Category.{u_4, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_6, u_7} C₂] [inst_2 : CategoryTheory.Category.{u_8, u_9} C₃]
[inst_3 : CategoryTheory.Category.{u_2, u_3} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | false |
Std.Internal.List.minKey!_modifyKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqOrd α]
[inst_4 : Std.LawfulEqOrd α] [inst_5 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {f : β k → β k},
Std.Internal.List.minKey! (Std.Internal.List.modifyKe... | true |
Mathlib.Tactic.ITauto.instLTIProp | Mathlib.Tactic.ITauto | LT Mathlib.Tactic.ITauto.IProp | true |
Lean.Meta.RefinedDiscrTree.PreDiscrTree.ctorIdx | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} → Lean.Meta.RefinedDiscrTree.PreDiscrTree α → ℕ | false |
measurable_measure_prodMk_left | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {ν : MeasureTheory.Measure β}
[MeasureTheory.SFinite ν] {s : Set (α × β)}, MeasurableSet s → Measurable fun x => ν (Prod.mk x ⁻¹' s) | true |
Std.DHashMap.getKeyD_diff_of_not_mem_left | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {k fallback : α}, k ∉ m₁ → (m₁ \ m₂).getKeyD k fallback = fallback | true |
IsPrimitiveRoot.adjoinEquivRingOfIntegersOfPrimePow | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | {p k : ℕ} →
{K : Type u} →
[inst : Field K] →
{ζ : K} →
[hp : Fact (Nat.Prime p)] →
[inst_1 : CharZero K] →
[IsCyclotomicExtension {p ^ k} ℚ K] → IsPrimitiveRoot ζ (p ^ k) → ↥ℤ[ζ] ≃ₐ[ℤ] NumberField.RingOfIntegers K | true |
Pi.measurableNeg | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {ι : Type u_4} {α : ι → Type u_5} [inst : (i : ι) → Neg (α i)] [inst_1 : (i : ι) → MeasurableSpace (α i)]
[∀ (i : ι), MeasurableNeg (α i)], MeasurableNeg ((i : ι) → α i) | true |
Batteries.OrientedOrd.instLexOrd | Batteries.Classes.Deprecated | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] [inst_1 : Ord β] [Batteries.OrientedOrd α] [Batteries.OrientedOrd β],
Batteries.OrientedOrd (α × β) | true |
CategoryTheory.Limits.preservesSmallestCofilteredLimits_of_preservesCofilteredLimits | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.{0, 0, v₁, v₂, u₁, u₂} F | true |
LSeries.notation._aux_Mathlib_NumberTheory_LSeries_Basic___unexpand_LSeries_delta_1 | Mathlib.NumberTheory.LSeries.Basic | Lean.PrettyPrinter.Unexpander | false |
ValuationSubring.linearOrderOverring._proof_3 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K) (a b : { S // A ≤ S }), a ≤ b ∨ b ≤ a | false |
continuousAt_prod_of_discrete_right | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [DiscreteTopology β] {f : α × β → γ} {x : α × β},
ContinuousAt f x ↔ ContinuousAt (fun x_1 => f (x_1, x.2)) x.1 | true |
CategoryTheory.IsCofiltered.minToRight._proof_1 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.IsCofilteredOrEmpty C]
(j j' : C), ∃ x, True | false |
ValuationSubring.instSemilatticeSup | Mathlib.RingTheory.Valuation.ValuationSubring | {K : Type u} → [inst : Field K] → SemilatticeSup (ValuationSubring K) | true |
_private.Mathlib.Data.Set.Prod.0.Set.EqOn.right_of_eqOn_prodMap._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_2} {δ : Type u_1} {f f' : α → γ} {g g' : β → δ} (x : α) ⦃x_1 : β⦄,
Prod.map f g (x, x_1) = Prod.map f' g' (x, x_1) → g x_1 = g' x_1 | false |
instReprOrdering | Init.Data.Ord.Basic | Repr Ordering | true |
Valuation.IsRankOneDiscrete.valueGroup₀_equiv_withZeroMulInt._proof_3 | Mathlib.RingTheory.Valuation.Discrete.RankOne | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {R : Type u_2} [inst_1 : CommRing R] (v : Valuation R Γ)
[hv : v.IsRankOneDiscrete], Subgroup.zpowers (Valuation.IsRankOneDiscrete.generator' v)⁻¹ = ⊤ | false |
Multiset.mapEquiv_aux._proof_3 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α], IsEmpty (Multiset.ToType ⟦[]⟧) | false |
Zsqrtd.isCoprime_of_dvd_isCoprime | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} {a b : ℤ√d}, IsCoprime a.re a.im → b ∣ a → IsCoprime b.re b.im | true |
Aesop.mkLocalRuleSet | Aesop.RuleSet | Array (Aesop.GlobalRuleSet × Lean.Name × Lean.Name) → Aesop.Options' → Lean.CoreM Aesop.LocalRuleSet | true |
_private.Lean.Elab.PreDefinition.TerminationMeasure.0.Lean.Elab.TerminationMeasure.structuralArg._sparseCasesOn_1 | Lean.Elab.PreDefinition.TerminationMeasure | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Set.definable_finset_sup | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {ι : Type u_2}
{f : ι → Set (α → M)}, (∀ (i : ι), A.Definable L (f i)) → ∀ (s : Finset ι), A.Definable L (s.sup f) | true |
Lean.Grind.Ring.OfSemiring.Q.ind | Init.Grind.Ring.Envelope | ∀ {α : Type u} [inst : Lean.Grind.Semiring α] {β : Lean.Grind.Ring.OfSemiring.Q α → Prop},
(∀ (a : α × α), β (Lean.Grind.Ring.OfSemiring.Q.mk a)) → ∀ (q : Lean.Grind.Ring.OfSemiring.Q α), β q | true |
CochainComplex.IsKProjective.homotopyZero_def | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) (hL : HomologicalComplex.Acyclic L) [inst_2 : K.IsKProjective],
CochainComplex.IsKProjective.homotopyZero f hL = ⋯.some | true |
CategoryTheory.Limits.spanIsoMk._auto_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | Lean.Syntax | false |
Lean.Parser.Command.GrindCnstr.notStrictValue.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer | true |
Mathlib.Tactic.ITauto.applyProof | Mathlib.Tactic.ITauto | Lean.MVarId → Lean.NameMap Lean.Expr → Mathlib.Tactic.ITauto.Proof → Lean.MetaM Unit | true |
OrderDual.btw | Mathlib.Order.Circular | (α : Type u_1) → [h : Btw α] → Btw αᵒᵈ | true |
Aesop.RuleApplication.mk | Aesop.RuleTac.Basic | Array Aesop.Subgoal →
Lean.Meta.SavedState → Option (Array Aesop.Script.LazyStep) → Option Aesop.Percent → Aesop.RuleApplication | true |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.VarMem_append._simp_1_2 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {a : α} {xs ys : Array α}, (a ∈ xs ++ ys) = (a ∈ xs ∨ a ∈ ys) | false |
SimplicialObject.Splitting.d | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : CategoryTheory.SimplicialObject C} →
(s : SimplicialObject.Splitting X) → [CategoryTheory.Preadditive C] → (i j : ℕ) → s.N i ⟶ s.N j | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get!_union_of_contains_eq_false_right._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.mkSparseCasesOn._sparseCasesOn_1 | Lean.Meta.Constructions.SparseCasesOn | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
instCountableFreeGroup | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u) [Countable α], Countable (FreeGroup α) | true |
Lean.Parser.Tactic.tacticHave' | Init.Tactics | Lean.ParserDescr | true |
OpenAddSubgroup.coe_toOpens | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] {U : OpenAddSubgroup G}, ↑↑U = ↑U | true |
Lean.JsonRpc.MessageKind.notification.elim | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.MessageKind → Sort u} →
(t : Lean.JsonRpc.MessageKind) → t.ctorIdx = 1 → motive Lean.JsonRpc.MessageKind.notification → motive t | false |
NonUnitalSubsemiringClass.toNonUnitalCommSemiring._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {S : Type u_2} (s : S) {R : Type u_1} [inst : NonUnitalCommSemiring R] [inst_1 : SetLike S R]
[inst_2 : NonUnitalSubsemiringClass S R] (a b : ↥s), a * b = b * a | false |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Presieve.functorPushforward_monotone.match_1_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} {X : C}
(x : CategoryTheory.Presieve X) (x_1 : D) (x_2 : x_1 ⟶ F.obj X)
(motive : CategoryTheory.Presieve.functorPushforward F x x_2 → Prop)
(x_3 : Categ... | false |
JoinedIn.mono | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {U V : Set X}, JoinedIn U x y → U ⊆ V → JoinedIn V x y | true |
Lean.Lsp.LeanFileProgressProcessingInfo.mk.inj | Lean.Data.Lsp.Extra | ∀ {range : Lean.Lsp.Range} {kind : Lean.Lsp.LeanFileProgressKind} {range_1 : Lean.Lsp.Range}
{kind_1 : Lean.Lsp.LeanFileProgressKind},
{ range := range, kind := kind } = { range := range_1, kind := kind_1 } → range = range_1 ∧ kind = kind_1 | true |
Std.Tactic.BVDecide.BVExpr.bitblast.mkFullAdderCarry._proof_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (lhs rhs cin : aig.Ref)
(hsub : aig.decls.size ≤ (aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.decls.size),
(aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.decls.size ≤
((aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.mkAndCach... | false |
_private.Mathlib.Analysis.InnerProductSpace.Projection.FiniteDimensional.0._aux_Mathlib_Analysis_InnerProductSpace_Projection_FiniteDimensional___unexpand_Inner_inner_1 | Mathlib.Analysis.InnerProductSpace.Projection.FiniteDimensional | Lean.PrettyPrinter.Unexpander | false |
SimpleGraph.Subgraph.instInfSet._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (s : Set G.Subgraph) {v w : V},
(∀ ⦃G' : G.Subgraph⦄, G' ∈ s → G'.Adj v w) ∧ G.Adj v w → v ∈ ⋂ i ∈ s, i.verts | false |
Condensed.lanPresheafNatIso | Mathlib.Condensed.Discrete.Colimit | {F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u + 1))} →
((S : Profinite) → CategoryTheory.Limits.IsColimit (F.mapCocone S.asLimitCone.op)) → (Condensed.lanPresheaf F ≅ F) | true |
_private.Mathlib.Algebra.Homology.CochainComplexOpposite.0.CochainComplex.homotopyUnop._proof_4 | Mathlib.Algebra.Homology.CochainComplexOpposite | ∀ (p p' : ℤ), p = p' → ComplexShape.embeddingUpIntDownInt.f p' = ComplexShape.embeddingUpIntDownInt.f p | false |
LieModule.genWeightSpace_zero_normalizer_eq_self | Mathlib.Algebra.Lie.Weights.Basic | ∀ (R : 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 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L], (LieModule.genWeightSpace M 0).normalizer = LieModule.genWeightS... | true |
CategoryTheory.Localization.liftNatIso_hom | Mathlib.CategoryTheory.Localization.Predicate | ∀ {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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) {E : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : L.IsLocalization W] (F₁ F₂ : CategoryTheor... | true |
isZGroup_iff_exists_mulEquiv | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] [Finite G],
IsZGroup G ↔ ∃ N H φ x, IsCyclic ↥H ∧ IsCyclic ↥N ∧ (Nat.card ↥N).Coprime (Nat.card ↥H) | true |
Finset.noncommProd_mulSingle | Mathlib.Data.Finset.NoncommProd | ∀ {ι : Type u_2} {M : ι → Type u_6} [inst : (i : ι) → Monoid (M i)] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι]
(x : (i : ι) → M i), Finset.univ.noncommProd (fun i => Pi.mulSingle i (x i)) ⋯ = x | true |
Topology.IsQuotientMap.trivializationOfSMulDisjoint.match_7 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_2} {X : Type u_1} {f : E → X} (U : Set E) (e : E) (motive : f e ∈ f '' U → Prop) (x : f e ∈ f '' U),
(∀ (e' : E) (he' : e' ∈ U) (hfe : f e' = f e), motive ⋯) → motive x | false |
CategoryTheory.pi.coconeOfCoconeCompEval | Mathlib.CategoryTheory.Limits.Pi | {I : Type v₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
{J : Type v₁} →
[inst_1 : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J ((i : I) → C i)} →
((i : I) → CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Pi.eval C... | true |
CategoryTheory.ShortComplex.ShortExact.fIsKernel._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.ShortExact → CategoryTheory.Mono S.f | false |
Nat.getElem?_toArray_rio | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i : ℕ}, (*...n).toArray[i]? = if i < n then some i else none | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.