name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Batteries.Tactic.GeneralizeProofs.0.Batteries.Tactic.GeneralizeProofs.withGeneralizedProofs.match_1 | Batteries.Tactic.GeneralizeProofs | (motive : Lean.Expr × Array (Lean.Expr × Lean.Expr) → Sort u_1) →
(__discr : Lean.Expr × Array (Lean.Expr × Lean.Expr)) →
((e : Lean.Expr) → (generalizations : Array (Lean.Expr × Lean.Expr)) → motive (e, generalizations)) → motive __discr | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.close | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Unbounded✝ α → EIO Std.CloseableChannel.Error Unit | true |
_private.Mathlib.MeasureTheory.Constructions.Pi.0.MeasureTheory.measurePreserving_arrowProdEquivProdArrow._simp_1_3 | Mathlib.MeasureTheory.Constructions.Pi | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | false |
CategoryTheory.Square.evaluation₁._proof_2 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : CategoryTheory.Square C} (f : X ⟶ Y)
(g : Y ⟶ Z), (CategoryTheory.CategoryStruct.comp f g).τ₁ = CategoryTheory.CategoryStruct.comp f.τ₁ g.τ₁ | false |
Int32.toNatClampNeg_pos_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ (n : Int32), (0 < n.toNatClampNeg) = (0 < n) | false |
Submonoid.mk_smul | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} [inst : MulOneClass M'] [inst_1 : SMul M' α] {S : Submonoid M'} (g : M') (hg : g ∈ S)
(a : α), ⟨g, hg⟩ • a = g • a | true |
LocallyConstant.mapMonoidHom.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {Z : Type u_6} [inst_1 : MulOneClass Y]
[inst_2 : MulOneClass Z] (f : Y →* Z),
LocallyConstant.mapMonoidHom f = { toFun := LocallyConstant.map ⇑f, map_one' := ⋯, map_mul' := ⋯ } | true |
CategoryTheory.Abelian.SpectralObject.isIso_map_fourδ₁Toδ₀_of_isZero | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι) {i₁ i₂ i₃ i₄ i₅ : ι}
(f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (f₂₃ : i₁ ⟶ i₃)
(h₂₃ : CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃) (n₀ n₁ n₂ : ℤ),
CategoryTheory.Limits.IsZero ((X.H n₂).obj (CategoryTheory.ComposableArrows.mk₁ f₂)) →
∀ (hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.isIso_map_fourδ₁Toδ₀_of_isZero._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.isIso_map_fourδ₁Toδ₀_of_isZero._auto_3),
CategoryTheory.IsIso
(X.map f₂₃ f₄ f₅ f₃ f₄ f₅ (CategoryTheory.ComposableArrows.fourδ₁Toδ₀ f₂ f₃ f₄ f₅ f₂₃ h₂₃) n₀ n₁ n₂ hn₁ hn₂) | true |
_private.Mathlib.Tactic.Simproc.VecPerm.0.Mathlib.Tactic.FinVec.arrayOfVecFinQ.match_3 | Mathlib.Tactic.Simproc.VecPerm | (motive : Option (Option (Array ℕ)) → Sort u_1) →
(x : Option (Option (Array ℕ))) → (Unit → motive none) → ((a : Option (Array ℕ)) → motive (some a)) → motive x | false |
MvPFunctor.M.dest | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → {α : TypeVec.{u} n} → P.M α → ↑P (α ::: P.M α) | true |
Mathlib.Tactic.UnfoldBoundary.UnfoldEntry.cast.sizeOf_spec | Mathlib.Tactic.Translate.UnfoldBoundary | ∀ (declName unfold refold unfold' refold' : Lean.Name),
sizeOf (Mathlib.Tactic.UnfoldBoundary.UnfoldEntry.cast declName unfold refold unfold' refold') =
1 + sizeOf declName + sizeOf unfold + sizeOf refold + sizeOf unfold' + sizeOf refold' | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.casesOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.PreprocessKind✝ → Sort u} →
(t : Lean.Meta.PreprocessKind✝¹) →
motive Lean.Meta.PreprocessKind.noMVars✝ →
motive Lean.Meta.PreprocessKind.mvarsNoOutputParams✝ →
motive Lean.Meta.PreprocessKind.mvarsOutputParams✝ → motive t | false |
Filter.CardinalGenerateSets.casesOn | Mathlib.Order.Filter.CardinalInter | ∀ {α : Type u} {c : Cardinal.{u}} {g : Set (Set α)} {motive : (a : Set α) → Filter.CardinalGenerateSets g a → Prop}
{a : Set α} (t : Filter.CardinalGenerateSets g a),
(∀ {s : Set α} (a : s ∈ g), motive s ⋯) →
motive Set.univ ⋯ →
(∀ {s t : Set α} (a : Filter.CardinalGenerateSets g s) (a_1 : s ⊆ t), motive t ⋯) →
(∀ {S : Set (Set α)} (a : Cardinal.mk ↑S < c) (a_1 : ∀ s ∈ S, Filter.CardinalGenerateSets g s),
motive (⋂₀ S) ⋯) →
motive a t | false |
DifferentiableAt.inv._simp_2 | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {R : Type u_5} [inst_3 : NormedDivisionRing R] [inst_4 : NormedAlgebra 𝕜 R] {h : E → R}
{z : E}, DifferentiableAt 𝕜 h z → h z ≠ 0 → DifferentiableAt 𝕜 h⁻¹ z = True | false |
Lean.Elab.Term.StructInst.SourcesView.noConfusion | Lean.Elab.StructInst | {P : Sort u} →
{t t' : Lean.Elab.Term.StructInst.SourcesView} → t = t' → Lean.Elab.Term.StructInst.SourcesView.noConfusionType P t t' | false |
AddSubgroup.finiteIndex_toSubgroup_iff._simp_1 | Mathlib.GroupTheory.Index | ∀ {G : Type u_3} [inst : AddGroup G] (H : AddSubgroup G), (AddSubgroup.toSubgroup H).FiniteIndex = H.FiniteIndex | false |
_private.Mathlib.Data.ENNReal.Basic.0.ENNReal.iInter_Ici_coe_nat._simp_1_1 | Mathlib.Data.ENNReal.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, Set.Ici a = (Set.Iio a)ᶜ | false |
CochainComplex.ConnectData.d_comp_d | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L) (n m p : ℤ),
CategoryTheory.CategoryStruct.comp (h.d n m) (h.d m p) = 0 | true |
Pell.Solution₁.instCommGroup._proof_6 | Mathlib.NumberTheory.Pell | ∀ {d : ℤ} (a : Pell.Solution₁ d), 1 * a = a | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.derivedLitsInvariant_confirmRupHint._proof_1_27 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (f_assignments_size : f.assignments.size = n)
(rupHints : Array ℕ) (i : Fin rupHints.size)
(acc :
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment ×
Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) × Bool × Bool)
(hsize : acc.1.size = n),
f.DerivedLitsInvariant f_assignments_size acc.1 hsize acc.2.1 →
∀ (hsize' : (Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint f.clauses acc rupHints[i]).1.size = n)
(h : ¬(acc.2.2.2 || acc.2.2.1) = true) (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)
(rupHint_clause_eq_c : f.clauses[rupHints[↑i]]? = some (some c)),
c.reduce acc.1 = Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty →
f.DerivedLitsInvariant f_assignments_size
(match c.reduce acc.1 with
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth => (acc.1, acc.2.1, true, false)
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty => (acc.1, acc.2.1, true, false)
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit (l, b) =>
if Std.Tactic.BVDecide.LRAT.Internal.Assignment.hasAssignment b acc.1[↑l]! = true then
(acc.1, acc.2.1, false, false)
else
(acc.1.modify (↑l) (Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment b), (l, b) :: acc.2.1,
false, false)
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToNonunit => (acc.1, acc.2.1, false, true)).1
⋯
(match c.reduce acc.1 with
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth => (acc.1, acc.2.1, true, false)
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty => (acc.1, acc.2.1, true, false)
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit (l, b) =>
if Std.Tactic.BVDecide.LRAT.Internal.Assignment.hasAssignment b acc.1[↑l]! = true then
(acc.1, acc.2.1, false, false)
else
(acc.1.modify (↑l) (Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment b), (l, b) :: acc.2.1,
false, false)
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToNonunit => (acc.1, acc.2.1, false, true)).2.1 | false |
Lean.Lsp.instFromJsonSignatureHelpOptions | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SignatureHelpOptions | true |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.isCocircuit_iff_minimal_compl_nonspanning._simp_1_3 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {s t u : Set α}, (s ⊆ t \ u) = (s ⊆ t ∧ Disjoint s u) | false |
Homeomorph.inv.eq_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [inst_2 : ContinuousInv G],
Homeomorph.inv G = { toEquiv := Equiv.inv G, continuous_toFun := ⋯, continuous_invFun := ⋯ } | true |
SubNegMonoid.mk._flat_ctor | Mathlib.Algebra.Group.Defs | {G : Type u} →
(add : G → G → G) →
(∀ (a b c : G), a + b + c = a + (b + c)) →
(zero : G) →
(∀ (a : G), 0 + a = a) →
(∀ (a : G), a + 0 = a) →
(nsmul : ℕ → G → G) →
autoParam (∀ (x : G), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n : ℕ) (x : G), nsmul (n + 1) x = nsmul n x + x) AddMonoid.nsmul_succ._autoParam →
(neg : G → G) →
(sub : G → G → G) →
autoParam (∀ (a b : G), a - b = a + neg b) SubNegMonoid.sub_eq_add_neg._autoParam →
(zsmul : ℤ → G → G) →
autoParam (∀ (a : G), zsmul 0 a = 0) SubNegMonoid.zsmul_zero'._autoParam →
autoParam (∀ (n : ℕ) (a : G), zsmul (↑n.succ) a = zsmul (↑n) a + a)
SubNegMonoid.zsmul_succ'._autoParam →
autoParam (∀ (n : ℕ) (a : G), zsmul (Int.negSucc n) a = neg (zsmul (↑n.succ) a))
SubNegMonoid.zsmul_neg'._autoParam →
SubNegMonoid G | false |
Set.projIcc_eq_right | Mathlib.Order.Interval.Set.ProjIcc | ∀ {α : Type u_1} [inst : LinearOrder α] {a b x : α} (h : a < b), Set.projIcc a b ⋯ x = ⟨b, ⋯⟩ ↔ b ≤ x | true |
CategoryTheory.Bicategory.Adj.inst._proof_24 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : CategoryTheory.Bicategory.Adj B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.Adj.Bicategory.associator f (CategoryTheory.CategoryStruct.id b) g).hom
(CategoryTheory.Bicategory.Adj.Bicategory.whiskerLeft f
(CategoryTheory.Bicategory.Adj.Bicategory.leftUnitor g).hom) =
CategoryTheory.Bicategory.Adj.Bicategory.whiskerRight (CategoryTheory.Bicategory.Adj.Bicategory.rightUnitor f).hom g | false |
_private.Mathlib.Topology.UniformSpace.Separation.0.t0Space_iff_ker_uniformity._simp_1_6 | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} {x : α × α}, (x ∈ Set.diagonal α) = (x.1 = x.2) | false |
CategoryTheory.Bicategory.Adjunction.homEquiv₁_apply | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {b c d : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : b ⟶ d} {h : c ⟶ d}
(γ : g ⟶ CategoryTheory.CategoryStruct.comp l h),
adj.homEquiv₁ γ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft r γ)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator r l h).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight adj.counit h)
(CategoryTheory.Bicategory.leftUnitor h).hom)) | true |
Std.Time.Year.instDecidableLeOffset | Std.Time.Date.Unit.Year | {x y : Std.Time.Year.Offset} → Decidable (x ≤ y) | true |
Lean.Parser.Term.logNamedErrorAtMacro._regBuiltin.Lean.Parser.Term.logNamedErrorAtMacro.docString_3 | Lean.Parser.Term | IO Unit | false |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.toArray_eq_match_step.match_1.eq_1 | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type u_1} (motive : Std.IterStep (Std.Iter β) β → Sort u_2) (it' : Std.Iter β) (out : β)
(h_1 : (it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.Iter β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.yield it' out with
| Std.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it' => h_2 it'
| Std.IterStep.done => h_3 ()) =
h_1 it' out | true |
Lean.ExternEntry.ctorIdx | Lean.Compiler.ExternAttr | Lean.ExternEntry → ℕ | false |
_private.Mathlib.Data.NNReal.Basic.0.NNReal.natCast_iInf._simp_1_1 | Mathlib.Data.NNReal.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] [Nonempty ι] {f : ι → α} {a : α},
BddBelow (Set.range f) → (a ≤ iInf f) = ∀ (i : ι), a ≤ f i | false |
Std.IterM.toArray.go.match_1 | Init.Data.Iterators.Consumers.Monadic.Collect | {α β : Type u_1} →
{m : Type u_1 → Type u_2} →
[inst : Std.Iterator α m β] →
(it : Std.IterM m β) →
(motive : it.Step → Sort u_3) →
(x : it.Step) →
((it' : Std.IterM m β) →
(out : β) →
(h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' out, h⟩) →
((it' : Std.IterM m β) →
(h : it.IsPlausibleStep (Std.IterStep.skip it')) → motive ⟨Std.IterStep.skip it', h⟩) →
((property : it.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, property⟩) → motive x | false |
AbsoluteValue.IsEquiv.rfl | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} [inst_1 : Semiring S] [inst_2 : PartialOrder S]
{v : AbsoluteValue R S}, v.IsEquiv v | true |
Filter.Germ.instInvolutiveInv._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {G : Type u_2} [inst : InvolutiveInv G] (q : Quotient (l.germSetoid G)), q⁻¹⁻¹ = q | false |
CategoryTheory.MorphismProperty.bijective_respectsIso | Mathlib.CategoryTheory.MorphismProperty.Concrete | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type u_2}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC],
(CategoryTheory.MorphismProperty.bijective C).RespectsIso | true |
Polynomial.instGroupGal._aux_4 | Mathlib.FieldTheory.PolynomialGaloisGroup | {F : Type u_1} → [inst : Field F] → (p : Polynomial F) → p.Gal | false |
Algebra.Generators.Hom.casesOn | Mathlib.RingTheory.Extension.Generators | {R : Type u} →
{S : Type v} →
{ι : Type w} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{P : Algebra.Generators R S ι} →
{R' : Type u_1} →
{S' : Type u_2} →
{ι' : Type u_3} →
[inst_3 : CommRing R'] →
[inst_4 : CommRing S'] →
[inst_5 : Algebra R' S'] →
{P' : Algebra.Generators R' S' ι'} →
[inst_6 : Algebra S S'] →
{motive : P.Hom P' → Sort u_4} →
(t : P.Hom P') →
((val : ι → P'.Ring) →
(aeval_val :
∀ (i : ι),
(MvPolynomial.aeval P'.val) (val i) = (algebraMap S S') (P.val i)) →
motive { val := val, aeval_val := aeval_val }) →
motive t | false |
Std.Sat.AIG.Decl.atom.noConfusion | Std.Sat.AIG.Basic | {α : Type} →
{P : Sort u} → {idx idx' : α} → Std.Sat.AIG.Decl.atom idx = Std.Sat.AIG.Decl.atom idx' → (idx ≍ idx' → P) → P | false |
OrderDual.instAddCommGroupWithOne._proof_1 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : AddCommGroupWithOne R], ↑0 = 0 | false |
Finset.sum_partition | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] {f : ι → M} (R : Setoid ι)
[inst_1 : DecidableRel ⇑R], ∑ x ∈ s, f x = ∑ xbar ∈ Finset.image (Quotient.mk R) s, ∑ y ∈ s with ⟦y⟧ = xbar, f y | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.getKey!.eq_1 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Inhabited α] (a : α),
Std.DHashMap.Internal.AssocList.getKey! a Std.DHashMap.Internal.AssocList.nil =
panicWithPosWithDecl "Std.Data.DHashMap.Internal.AssocList.Basic" "Std.DHashMap.Internal.AssocList.getKey!" 168 11
"key is not present in hash table" | true |
_private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.type_eq_zero_iff_isEmpty.match_1_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u_1} {r : α → α → Prop} (motive : Nonempty (r ≃r emptyRelation) → Prop) (x : Nonempty (r ≃r emptyRelation)),
(∀ (s : r ≃r emptyRelation), motive ⋯) → motive x | false |
NumberField.mixedEmbedding.norm_eq_zero_iff | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {x : NumberField.mixedEmbedding.mixedSpace K},
NumberField.mixedEmbedding.norm x = 0 ↔ ∃ w, (NumberField.mixedEmbedding.normAtPlace w) x = 0 | true |
AlgebraicIndependent.extendScalars | Mathlib.RingTheory.AlgebraicIndependent.AlgebraicClosure | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_4} {x : ι → A} (S : Type u_5) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : CommRing A] [inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A]
[NoZeroDivisors S], AlgebraicIndependent R x → ∀ [alg : Algebra.IsAlgebraic R S], AlgebraicIndependent S x | true |
Lean.Lsp.instFileSourcePlainTermGoalParams | Lean.Server.FileSource | Lean.Lsp.FileSource Lean.Lsp.PlainTermGoalParams | true |
AddCommGroup.neg_modEq_neg._simp_1 | Mathlib.Algebra.Group.ModEq | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a b : G}, (-a ≡ -b [PMOD p]) = (a ≡ b [PMOD p]) | false |
ValuationSubring.algebra._proof_4 | Mathlib.RingTheory.Valuation.AlgebraInstances | ∀ {K : Type u_2} [inst : Field K] (v : Valuation K (WithZero (Multiplicative ℤ))) (L : Type u_3) [inst_1 : Field L]
[inst_2 : Algebra K L] (E : Type u_1) [inst_3 : Field E] [inst_4 : Algebra K E] [inst_5 : Algebra L E]
[inst_6 : IsScalarTower K L E] (x y : ↥(integralClosure (↥v.valuationSubring) L)),
↑⟨(algebraMap L E) ↑(x + y), ⋯⟩ = ↑(⟨(algebraMap L E) ↑x, ⋯⟩ + ⟨(algebraMap L E) ↑y, ⋯⟩) | false |
Lean.Meta.Simp.Simprocs.post | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simprocs → Lean.Meta.Simp.SimprocTree | true |
DoubleQuot.coe_quotQuotEquivQuotOfLEₐ | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R : Type u) {A : Type u_1} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A] {I J : Ideal A}
(h : I ≤ J), ⇑(DoubleQuot.quotQuotEquivQuotOfLEₐ R h) = ⇑(DoubleQuot.quotQuotEquivQuotOfLE h) | true |
exists_smooth_tsupport_subset | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] {s : Set E} {x : E}
{n : ℕ∞},
s ∈ nhds x → ∃ f, tsupport f ⊆ s ∧ HasCompactSupport f ∧ ContDiff ℝ (↑n) f ∧ Set.range f ⊆ Set.Icc 0 1 ∧ f x = 1 | true |
Lean.Elab.Term.MutualClosure.LetRecClosure._sizeOf_1 | Lean.Elab.MutualDef | Lean.Elab.Term.MutualClosure.LetRecClosure → ℕ | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Util.0.Lean.Grind.Linarith.Poly.updateOccs.go | Lean.Meta.Tactic.Grind.Arith.Linear.Util | Lean.Grind.Linarith.Var → Lean.Grind.Linarith.Poly → Lean.Meta.Grind.Arith.Linear.LinearM Unit | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.hasLiftingPropertyFixedBot_ι_app_bot | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
{X Y : C} {p : X ⟶ Y} {g : c.pt ⟶ Y} [F.IsWellOrderContinuous] [inst_4 : SuccOrder J] [WellFoundedLT J],
(∀ (j : J),
¬IsMax j →
CategoryTheory.HasLiftingPropertyFixedBot (F.map (CategoryTheory.homOfLE ⋯)) p
(CategoryTheory.CategoryStruct.comp (c.ι.app (Order.succ j)) g)) →
CategoryTheory.HasLiftingPropertyFixedBot (c.ι.app ⊥) p g | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Cycle.support_formPerm._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {a b : ℕ}, (a.succ ≤ b.succ) = (a ≤ b) | false |
Finset.pow_right_strictMono | Mathlib.Geometry.Group.Growth.LinearLowerBound | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {X : Finset G},
1 ∈ X → (↑(Subgroup.closure ↑X)).Infinite → StrictMono fun n => X ^ n | true |
DistLat.instCategory._proof_2 | Mathlib.Order.Category.DistLat | ∀ {X Y : DistLat} (f : X.Hom Y), { hom' := { hom' := LatticeHom.id ↑Y }.hom'.comp f.hom' } = f | false |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.tgtM._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[Monad m] →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ m] →
Mathlib.Tactic.BicategoryLike.WhiskerLeft → m Mathlib.Tactic.BicategoryLike.Mor₁ | false |
SimplexCategory.Truncated.incl._proof_1 | Mathlib.AlgebraicTopology.SimplexCategory.Defs | ∀ (n m : ℕ), n ≤ m → ∀ (x : SimplexCategory), x.len ≤ n → x.len ≤ m | false |
zpow_right_inj₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : LinearOrder G₀] {a : G₀} {m n : ℤ} [PosMulStrictMono G₀]
[ZeroLEOneClass G₀], 0 < a → a ≠ 1 → (a ^ m = a ^ n ↔ m = n) | true |
_private.Mathlib.NumberTheory.RatFunc.Ostrowski.0.RatFunc.uniformizingPolynomial_isUniformizer.match_1_4 | Mathlib.NumberTheory.RatFunc.Ostrowski | ∀ {K : Type u_2} {Γ : Type u_1} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [inst_2 : v.IsNontrivial] [inst_3 : Valuation.IsTrivialOn K v] (hle : v RatFunc.X ≤ 1)
(h0 : v ↑(RatFunc.uniformizingPolynomial hle) ≠ 0) (γ : Γˣ) (motive : (∃ k, ⋯.unit ^ k = γ) → Prop)
(x : ∃ k, ⋯.unit ^ k = γ), (∀ (k : ℤ) (hk : ⋯.unit ^ k = γ), motive ⋯) → motive x | false |
Aesop.BuiltinRules.destructProductsCore | Aesop.BuiltinRules.DestructProducts | Lean.MVarId → Lean.Meta.TransparencyMode → Aesop.BaseM (Lean.MVarId × Array Aesop.Script.LazyStep) | true |
Lean.Meta.Sym.Internal.mkFVarS | Lean.Meta.Sym.AlphaShareBuilder | {m : Type → Type} → [Lean.Meta.Sym.Internal.MonadShareCommon m] → Lean.FVarId → m Lean.Expr | true |
Set.decidableInsert | Mathlib.Data.Set.Basic | {α : Type u} → (s : Set α) → (a b : α) → [Decidable (a = b)] → [Decidable (a ∈ s)] → Decidable (a ∈ insert b s) | true |
_private.Mathlib.RingTheory.LocalRing.ResidueField.Basic.0.IsLocalRing.ResidueField.instIsScalarTower_1._simp_1 | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.fastUmulOverflow._proof_1_20 | Init.Data.BitVec.Bitblast | ∀ (w : ℕ) (x y : BitVec (w + 1 + 1)),
¬x.clz.toNat + y.clz.toNat ≤ w →
¬w + 1 < y.clz.toNat → ¬w + 1 + 1 - x.clz.toNat + (w + 1 + 1 - y.clz.toNat) ≤ w + 1 + 1 + 1 → False | false |
_private.Mathlib.MeasureTheory.Integral.Average.0.MeasureTheory.setLAverage_const._simp_1_1 | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | false |
Lean.Server.FileWorker.FileSetupResult.noLakefile.sizeOf_spec | Lean.Server.FileWorker.SetupFile | sizeOf Lean.Server.FileWorker.FileSetupResult.noLakefile = 1 | true |
Ordinal.ofNat_lt_card._simp_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ {o : Ordinal.{u_1}} {n : ℕ} [inst : n.AtLeastTwo], (OfNat.ofNat n < o.card) = (OfNat.ofNat n < o) | false |
AddSubgroup.map_iInf | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {ι : Sort u_7} [Nonempty ι] (f : G →+ N),
Function.Injective ⇑f → ∀ (s : ι → AddSubgroup G), AddSubgroup.map f (iInf s) = ⨅ i, AddSubgroup.map f (s i) | true |
MeasureTheory.Integrable.enorm | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] {f : α → ε}, MeasureTheory.Integrable f μ → MeasureTheory.Integrable (fun x => ‖f x‖ₑ) μ | true |
MvPolynomial.ACounit_surjective | Mathlib.Algebra.MvPolynomial.Counit | ∀ (A : Type u_1) (B : Type u_2) [inst : CommSemiring A] [inst_1 : CommSemiring B] [inst_2 : Algebra A B],
Function.Surjective ⇑(MvPolynomial.ACounit A B) | true |
Pi.evalNonUnitalStarAlgHom._proof_5 | Mathlib.Algebra.Star.StarAlgHom | ∀ {ι : Type u_2} (A : ι → Type u_1) (j : ι) [inst : (i : ι) → NonUnitalNonAssocSemiring (A i)]
[inst_1 : (i : ι) → Star (A i)] (x : (i : ι) → A i),
(Pi.evalMulHom A j).toFun (star x) = (Pi.evalMulHom A j).toFun (star x) | false |
_private.Lean.Meta.Tactic.Grind.AC.Proof.0.Lean.Meta.Grind.AC.toContextExpr._proof_1 | Lean.Meta.Tactic.Grind.AC.Proof | ∀ (vars : Array Lean.Expr) (x : Fin vars.size), ↑x < vars.size | false |
_private.Lean.Server.Rpc.RequestHandling.0.Lean.Server.handleRpcCall.match_3 | Lean.Server.Rpc.RequestHandling | (motive : Except String Lean.Server.RpcProcedure → Sort u_1) →
(x : Except String Lean.Server.RpcProcedure) →
((x : Lean.Server.RpcProcedure) → motive (Except.ok x)) → ((e : String) → motive (Except.error e)) → motive x | false |
Turing.PartrecToTM2.contStack.eq_def | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (x : Turing.ToPartrec.Cont),
Turing.PartrecToTM2.contStack x =
match x with
| Turing.ToPartrec.Cont.halt => []
| Turing.ToPartrec.Cont.cons₁ a ns k => ns :: Turing.PartrecToTM2.contStack k
| Turing.ToPartrec.Cont.cons₂ ns k => ns :: Turing.PartrecToTM2.contStack k
| Turing.ToPartrec.Cont.comp a k => Turing.PartrecToTM2.contStack k
| Turing.ToPartrec.Cont.fix a k => Turing.PartrecToTM2.contStack k | true |
AlgebraicGeometry.Scheme.IdealSheafData.subschemeι_app | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (U : ↑X.affineOpens),
AlgebraicGeometry.Scheme.Hom.app I.subschemeι ↑U =
CategoryTheory.CategoryStruct.comp (CommRingCat.ofHom (Ideal.Quotient.mk (I.ideal U))) (I.subschemeObjIso U).inv | true |
Algebra.Extension.toBaseChange | Mathlib.RingTheory.Extension.Basic | {R : Type u} →
{S : Type v} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{P : Algebra.Extension R S} →
(T : Type u_1) → [inst_3 : CommRing T] → [inst_4 : Algebra R T] → P.Hom P.baseChange | true |
FourierInvPair.rec | Mathlib.Analysis.Fourier.Notation | {E : Type u_5} →
{F : Type u_6} →
[inst : FourierTransform F E] →
[inst_1 : FourierTransformInv E F] →
{motive : FourierInvPair E F → Sort u} →
((fourier_fourierInv_eq : ∀ (f : E), FourierTransform.fourier (FourierTransformInv.fourierInv f) = f) →
motive ⋯) →
(t : FourierInvPair E F) → motive t | false |
isGLB_inv | Mathlib.Algebra.Order.Group.Pointwise.Bounds | ∀ {G : Type u_2} [inst : Group G] [inst_1 : Preorder G] [MulLeftMono G] [MulRightMono G] {s : Set G} {a : G},
IsGLB s⁻¹ a ↔ IsLUB s a⁻¹ | true |
HomologicalComplex.dTo | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} → (C : HomologicalComplex V c) → (j : ι) → C.xPrev j ⟶ C.X j | true |
IsLprojection.Subtype.zero._proof_3 | Mathlib.Analysis.Normed.Module.MStructure | ∀ {X : Type u_1} [inst : NormedAddCommGroup X] {M : Type u_2} [inst_1 : Ring M] [inst_2 : Module M X], IsLprojection X 0 | false |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.opowAux.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Notation | ∀ (motive : ℕ → ℕ → Sort u_1) (x : ℕ) (h_1 : (x : ℕ) → motive x 0) (h_2 : (m : ℕ) → motive 0 m.succ)
(h_3 : (k m : ℕ) → motive k.succ m),
(match x, 0 with
| x, 0 => h_1 x
| 0, m.succ => h_2 m
| k.succ, m => h_3 k m) =
h_1 x | true |
Bracket.casesOn | Mathlib.Data.Bracket | {L : Type u_1} →
{M : Type u_2} →
{motive : Bracket L M → Sort u} →
(t : Bracket L M) → ((bracket : L → M → M) → motive { bracket := bracket }) → motive t | false |
MeasureTheory.hasFiniteIntegral_const_iff_isFiniteMeasure | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{c : β}, c ≠ 0 → (MeasureTheory.HasFiniteIntegral (fun x => c) μ ↔ MeasureTheory.IsFiniteMeasure μ) | true |
ModuleCat.ctorIdx | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} → {inst : Ring R} → ModuleCat R → ℕ | false |
Lean.IR.EmitC.hasMainFn | Lean.Compiler.IR.EmitC | Lean.IR.EmitC.M Bool | true |
Asymptotics.isLittleO_top._simp_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {F' : Type u_7} {E'' : Type u_9} [inst : SeminormedAddCommGroup F'] [inst_1 : NormedAddCommGroup E'']
{g' : α → F'} {f'' : α → E''}, f'' =o[⊤] g' = ∀ (x : α), f'' x = 0 | false |
SeparatelyContinuousAdd.mk | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Add M],
(∀ {a : M}, Continuous fun x => a + x) → (∀ {a : M}, Continuous fun x => x + a) → SeparatelyContinuousAdd M | true |
localizedModuleIsLocalizedModule | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M], IsLocalizedModule S (LocalizedModule.mkLinearMap S M) | true |
Lean.Meta.ACLt.ReduceMode.noConfusionType | Lean.Meta.ACLt | Sort v✝ → Lean.Meta.ACLt.ReduceMode → Lean.Meta.ACLt.ReduceMode → Sort v✝ | true |
CategoryTheory.ParametrizedAdjunction._sizeOf_1 | Mathlib.CategoryTheory.Adjunction.Parametrized | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{inst : CategoryTheory.Category.{v₁, u₁} C₁} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} C₂} →
{inst_2 : CategoryTheory.Category.{v₃, u₃} C₃} →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} →
[SizeOf C₁] → [SizeOf C₂] → [SizeOf C₃] → (F ⊣₂ G) → ℕ | false |
Std.Internal.List.maxKey?_of_perm | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l l' : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l → l.Perm l' → Std.Internal.List.maxKey? l = Std.Internal.List.maxKey? l' | true |
ContinuousLinearMap.ring_lmap_equiv_selfₗ._proof_9 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], IsScalarTower 𝕜 𝕜 E | false |
CategoryTheory.Limits.CoproductsFromFiniteFiltered.isColimitFiniteSubproductsCocone._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[inst_1 : CategoryTheory.Limits.HasFiniteCoproducts C] (f : α → C)
[inst_2 : CategoryTheory.Limits.HasColimitsOfShape (Finset (CategoryTheory.Discrete α)) C]
[inst_3 : CategoryTheory.Limits.HasCoproduct f] (j : Finset (CategoryTheory.Discrete α)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.colimit.cocone
(CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetObj
(CategoryTheory.Discrete.functor f))).ι.app
j)
((CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone
(CategoryTheory.Discrete.functor f)).isColimit.coconePointUniqueUpToIso
(CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor f))).hom =
(CategoryTheory.Limits.CoproductsFromFiniteFiltered.finiteSubcoproductsCocone f).ι.app j | false |
NNReal.nhds_zero | Mathlib.Topology.Instances.NNReal.Lemmas | nhds 0 = ⨅ a, ⨅ (_ : a ≠ 0), Filter.principal (Set.Iio a) | true |
Relation.fun_eq_comp | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {r : α → β → Prop} (f : γ → α),
Relation.Comp (fun x1 x2 => f x1 = x2) r = fun x => r (f x) | true |
CategoryTheory.IsPreconnected | Mathlib.CategoryTheory.IsConnected | (J : Type u₁) → [CategoryTheory.Category.{v₁, u₁} J] → Prop | true |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable.0.Multiset.aestronglyMeasurable_fun_prod._simp_1_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_7} {M : α → Type u_8} [inst : (a : α) → CommMonoid (M a)] (a : α) (s : Multiset ((a : α) → M a)),
(Multiset.map (fun f => f a) s).prod = s.prod a | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.