name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_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 α] (head : α) (tail : List α) {n s : ℕ},
n + 1 ≤ (List.idxsOf x (head :: tail) s).length → n < (List.idxsOf x (head :: tail) s).length | null | 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... | null | 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 | null | 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 | null | false |
Inclusion.Univ.mk.noConfusion | Mathlib.Tactic.Inclusion.Core.ToSet | {Iα : Type u_1} →
{α : Type u_2} →
{inst : Inclusion.ToSet Iα α} →
{P : Sort u} →
{univ : Iα} →
{mem_univ : ∀ (x : α), x ∈ univ} →
{univ' : Iα} →
{mem_univ' : ∀ (x : α), x ∈ univ'} →
{ univ := univ, mem_univ := mem_univ } = { univ := univ', mem_uni... | null | false |
Mathlib.Meta.FunProp.instInhabitedFunPropDecl | Mathlib.Tactic.FunProp.Decl | Inhabited Mathlib.Meta.FunProp.FunPropDecl | null | 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) | null | false |
AddAction.orbitRel | Mathlib.GroupTheory.GroupAction.Defs | (G : Type u_1) → (α : Type u_2) → [inst : AddGroup G] → [AddAction G α] → Setoid α | The relation 'in the same orbit'. | 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 | null | true |
Lean.Name.getRoot._sunfold | Init.Meta.Defs | Lean.Name → Lean.Name | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0._regBuiltin.Int8.reduceToInt.declare_88._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2990342300._hygCtx._hyg.418 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | 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 | null | 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₂ | null | 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 | null | 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) | null | true |
Lean.Meta.RecursorInfo | Lean.Meta.RecursorInfo | Type | null | 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 ... | null | false |
Hyperreal.instField._aux_70 | Mathlib.Analysis.Real.Hyperreal | ℚ → ℝ* → ℝ* | null | 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 | null | 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... | null | true |
Nat.forall_lt_succ_left'._proof_2 | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, 0 < n + 1 | null | false |
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 | null | 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) | Transport an adjunction along a natural isomorphism on the left. | true |
Lean.Elab.CommandContextInfo.ctorIdx | Lean.Elab.InfoTree.Types | Lean.Elab.CommandContextInfo → ℕ | null | false |
Topology.«_aux_Mathlib_Topology_Defs_Filter___macroRules_Topology_term𝓝ˢ_1» | Mathlib.Topology.Defs.Filter | Lean.Macro | null | false |
TopologicalSpace.secondCountableTopology_iInf | Mathlib.Topology.Bases | ∀ {α : Type u_1} {ι : Sort u_2} [Countable ι] {t : ι → TopologicalSpace α},
(∀ (i : ι), SecondCountableTopology α) → SecondCountableTopology α | null | true |
ENNReal.toReal_lt_toReal | Mathlib.Basic.ENNReal.Real | ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → (a.toReal < b.toReal ↔ a < b) | null | 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 | null | false |
Std.Time.TimeZone.DaylightSavingRule.start._default | Std.Time.Zoned.RecurringRule | Option Std.Time.TimeZone.TransitionRule | null | false |
Set.nontrivial_of_einfsep_ne_top | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Set α}, s.einfsep ≠ ⊤ → s.Nontrivial | null | 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 : ... | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat.0._auto_142 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | Lean.Syntax | null | false |
EuclideanGeometry.instNonemptySphere | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} [inst : MetricSpace P] [Nonempty P], Nonempty (EuclideanGeometry.Sphere P) | null | true |
Lake.instReprComparatorOp | Lake.Util.Version | Repr Lake.ComparatorOp | null | true |
Lean.Meta.eqnThmSuffixBase | Lean.Meta.Eqns | String | null | 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) | null | true |
ProbabilityTheory.Indistinguishable.fun_div | Mathlib.Probability.Process.Indistinguishable | ∀ {ι : Type u_1} {Ω : Type u_2} {E : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X Y : ι → Ω → E}
[inst : Div E] {Z T : ι → Ω → E},
X ≡ᵐ[P] Y → Z ≡ᵐ[P] T → (fun i i_1 => X i i_1 / Z i i_1) ≡ᵐ[P] fun i i_1 => Y i i_1 / T i i_1 | Eta-expanded form of `ProbabilityTheory.Indistinguishable.div` | true |
LeanSearchClient.SearchResult.mk._flat_ctor | LeanSearchClient.Syntax | String → Option String → Option String → Option String → Option String → LeanSearchClient.SearchResult | null | 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 | null | true |
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... | null | 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... | null | true |
Mathlib.Tactic.ITauto.instLTIProp | Mathlib.Tactic.ITauto | LT Mathlib.Tactic.ITauto.IProp | null | true |
Lean.Meta.RefinedDiscrTree.PreDiscrTree.ctorIdx | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} → Lean.Meta.RefinedDiscrTree.PreDiscrTree α → ℕ | null | 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) | If `ν` is an s-finite measure, and `s ⊆ α × β` is measurable, then `x ↦ ν { y | (x, y) ∈ s }`
is a measurable function.
Not true without the s-finite assumption: on `ℝ × ℝ` with the product sigma-algebra, let `s` be the
diagonal and let `ν` be an uncountable sum of Dirac measures (all Dirac measures for points in a
se... | true |
CategoryTheory.Aut.val_unitsEndEquivAut_symm_apply_asHom | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C) (f : CategoryTheory.Aut X),
(↑((CategoryTheory.Aut.unitsEndEquivAut X).symm f)).asHom = f.asIso.hom | null | 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 | null | 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 | The algebra isomorphism `adjoin ℤ {ζ} ≃ₐ[ℤ] (𝓞 K)`, where `ζ` is a primitive `p ^ k`-th root of
unity and `K` is a `p ^ k`-th cyclotomic extension of `ℚ`. | 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) | null | 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 | Preserving cofiltered limits at any universe implies preserving cofiltered limits at universe `0`.
| true |
LSeries.notation._aux_Mathlib_NumberTheory_LSeries_Basic___unexpand_LSeries_delta_1 | Mathlib.NumberTheory.LSeries.Basic | Lean.PrettyPrinter.Unexpander | null | 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 | null | 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 | null | 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 | null | false |
ValuationSubring.instSemilatticeSup | Mathlib.RingTheory.Valuation.ValuationSubring | {K : Type u} → [inst : Field K] → SemilatticeSup (ValuationSubring K) | null | 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 | null | false |
instReprOrdering | Init.Data.Ord.Basic | Repr Ordering | null | true |
Valuation.IsRankOneDiscrete.valueGroup₀_equiv_withZeroMulInt._proof_3 | Mathlib.RingTheory.Valuation.Discrete.RankOne | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {R : Type u_2} [inst_1 : Ring R] (v : Valuation R Γ)
[hv : v.IsRankOneDiscrete], Subgroup.zpowers (Valuation.IsRankOneDiscrete.generator' v)⁻¹ = ⊤ | null | false |
Inclusion.mkInclusionTrueProof | Mathlib.Tactic.Inclusion.Core.Core | Lean.Expr → Lean.MetaM Lean.Expr | Check that `inclusionExpr` equals `IntervalBool.true` using a compiled computation, and then
pass the proof term to the kernel (where it will be verified again by reflection). | true |
AddSubgroup.Commensurable.bot_right_iff._simp_1 | Mathlib.GroupTheory.Commensurable | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.Commensurable ⊥ = Finite ↥H | null | 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 | null | true |
ssubset_iff_subset_not_superset | Mathlib.Order.RelClasses | ∀ {α : Type u_1} [UsesSetNotationForOrder α] [inst : Preorder α] {a b : α}, a ⊂ b ↔ a ⊆ b ∧ ¬b ⊆ a | Set notation form of `lt_iff_le_not_ge` | true |
Aesop.mkLocalRuleSet | Aesop.RuleSet | Array (Aesop.GlobalRuleSet × Lean.Name × Lean.Name) → Aesop.Options' → Lean.CoreM Aesop.LocalRuleSet | null | 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 | null | 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) | null | true |
_private.Mathlib.RingTheory.Flat.Rank.0.PrimeSpectrum.rankAtStalk_pos_iff_comap_surjective._simp_1_3 | Mathlib.RingTheory.Flat.Rank | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s | null | false |
_private.Mathlib.CategoryTheory.Monoidal.Mon.0.CategoryTheory.Functor.FullyFaithful.isMonHom_preimage._simp_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] (X : C) [inst_5 : CategoryTheory.MonObj X] {Z : ... | null | false |
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 | null | 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 | null | true |
CategoryTheory.Limits.spanIsoMk._auto_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | Lean.Syntax | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas.0.RootPairing.exists_coroot_sub_coroot_eq_zsmul._proof_1_1 | Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas | ∀ {ι : Type u_2} {R : Type u_3} {M : Type u_1} {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 k : ι},
P.root k = P.root j - P.root i → k = j → P.root i = 0 | null | false |
Lean.Parser.Command.GrindCnstr.notStrictValue.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer | null | true |
Set.iUnion_Icc_eq_Iic_self_iff | Mathlib.Order.Interval.Set.Disjoint | ∀ {ι : Sort u} {α : Type v} [inst : LinearOrder α] {f : ι → α} {a : α},
⋃ i, Set.Icc (f i) a = Set.Iic a ↔ ∀ (x : α), a ≥ x → ∃ i, f i ≤ x | null | true |
Mathlib.Tactic.ITauto.applyProof | Mathlib.Tactic.ITauto | Lean.MVarId → Lean.NameMap Lean.Expr → Mathlib.Tactic.ITauto.Proof → Lean.MetaM Unit | Once we have a proof object, we have to apply it to the goal. | true |
String.contains_bool_eq | Init.Data.String.Lemmas.Pattern.Find.Pred | ∀ {p : Char → Bool} {s : String}, s.contains p = s.toList.any p | null | true |
OrderDual.btw | Mathlib.Order.Circular | (α : Type u_1) → [h : Btw α] → Btw αᵒᵈ | null | true |
Aesop.RuleApplication.mk | Aesop.RuleTac.Basic | Array Aesop.Subgoal →
Lean.Meta.SavedState → Option (Array Aesop.Script.LazyStep) → Option Aesop.Percent → Aesop.RuleApplication | null | 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) | null | false |
_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) | null | false |
_private.Mathlib.Data.Num.Lemmas.0.Num.isOrderedCancelAddMonoid._proof_2 | Mathlib.Data.Num.Lemmas | ∀ (a b c : Num), ↑a + ↑b ≤ ↑a + ↑c → ↑b ≤ ↑c | null | 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 | null | false |
instCountableFreeGroup | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u) [Countable α], Countable (FreeGroup α) | null | true |
ContinuousAffineMap.instIsTopologicalAddGroup | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_5} [inst : NormedField R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace P]
[inst_6 : AddCommGroup W] [inst_7 : Module R W] [inst_8 : TopologicalSpace W] [inst_9 : IsTopologi... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt32.reduceDiv.declare_186._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2393314560._hygCtx._hyg.111 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
Lean.Parser.Tactic.tacticHave' | Init.Tactics | Lean.ParserDescr | Similar to `have`, but using `refine'` | true |
OpenAddSubgroup.coe_toOpens | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] {U : OpenAddSubgroup G}, ↑↑U = ↑U | null | 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 | null | 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 | null | false |
Subalgebra.linearEquivOp._proof_7 | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A), Function.RightInverse S.addEquivOp.invFun S.addEquivOp.toFun | null | 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 | null | 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 | null | 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... | null | 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 | null | 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 | null | false |
_private.Mathlib.Topology.MetricSpace.GromovProduct.0.Metric.gromovProduct_add_gromovProduct₁₂._proof_1_1 | Mathlib.Topology.MetricSpace.GromovProduct | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] (x y z : X),
Metric.gromovProduct x y z + Metric.gromovProduct y x z = dist x y | null | 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) | `lanPresheafIso` is natural in `S`. | 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 | null | 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... | null | true |
Valuation.HasExtension.instAlgebra_valuationSubring._proof_7 | Mathlib.RingTheory.Valuation.Extension | ∀ {K : outParam (Type u_1)} {L : outParam (Type u_3)} {Γ₀ : outParam (Type u_2)} {Γ₁ : outParam (Type u_4)}
[inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [inst_3 : LinearOrderedCommGroupWithZero Γ₀]
[inst_4 : LinearOrderedCommGroupWithZero Γ₁] (vK : Valuation K Γ₀) (vL : Valuation L Γ₁) [inst_5 : vK.Ha... | null | false |
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... | null | 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) | A finite group `G` is a Z-group if and only if `G` is isomorphic to a semidirect product of two
cyclic subgroups of coprime order. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.