name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Array.elem_push_self | Init.Data.Array.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {xs : Array α} {a : α}, Array.elem a (xs.push a) = true |
Mathlib.Meta.Positivity.evalPowZeroNat | Mathlib.Tactic.Positivity.Basic | Mathlib.Meta.Positivity.PositivityExt |
LibraryNote.category_theory_universes | Mathlib.CategoryTheory.Category.Basic | Batteries.Util.LibraryNote |
Equiv.subtypePreimage._proof_7 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_2} {β : Sort u_1} (p : α → Prop) [inst : DecidablePred p] (x₀ : { a // p a } → β) (x : α → β)
(hx : x ∘ Subtype.val = x₀) (a : α),
↑((fun x => ⟨fun a => if h : p a then x₀ ⟨a, h⟩ else x ⟨a, h⟩, ⋯⟩) ((fun x a => ↑x ↑a) ⟨x, hx⟩)) a = ↑⟨x, hx⟩ a |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.RingId.0.Lean.Meta.Grind.Arith.CommRing.getCommSemiringId?.go? | Lean.Meta.Tactic.Grind.Arith.CommRing.RingId | Lean.Expr → Lean.Meta.Grind.GoalM (Option ℕ) |
Lean.Elab.HeaderProcessedSnapshot.noConfusionType | Lean.Elab.DefView | Sort u → Lean.Elab.HeaderProcessedSnapshot → Lean.Elab.HeaderProcessedSnapshot → Sort u |
Lean.instReprSMap | Lean.Data.SMap | {α : Type u_1} → {β : Type u_2} → {x : BEq α} → {x_1 : Hashable α} → [Repr α] → [Repr β] → Repr (Lean.SMap α β) |
_private.Init.Data.List.Nat.Count.0.List.countP_replace._proof_1_6 | Init.Data.List.Nat.Count | ∀ {α : Type u_1} [BEq α] {a : α} {b : α} {p : α → Bool} (x : α) (l : List α),
(¬((List.countP p l + if p b = true then 1 else 0) + if p x = true then 1 else 0) =
(List.countP p l + if p x = true then 1 else 0) + if p b = true then 1 else 0) →
False |
CategoryTheory.Classifier.χ_comp_hom_assoc | Mathlib.CategoryTheory.Topos.Classifier | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {𝒞₁ 𝒞₂ : CategoryTheory.Classifier C} {X Y : C} (m : X ⟶ Y)
[inst_1 : CategoryTheory.Mono m] {Z : C} (h : 𝒞₂.Ω ⟶ Z),
CategoryTheory.CategoryStruct.comp (𝒞₁.χ m) (CategoryTheory.CategoryStruct.comp (𝒞₁.hom 𝒞₂) h) =
CategoryTheory.CategoryStruct.comp (𝒞₂.χ m) h |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.δ_comp_δ._proof_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (i k : ℕ), k < i → i ≤ k → False |
FractionalIdeal.definition._proof_3._@.Mathlib.RingTheory.FractionalIdeal.Operations.2078496209._hygCtx._hyg.2 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R), Submonoid.map (RingEquiv.refl R).toMonoidHom S = S |
Polynomial.evalEval_neg | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : Ring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.evalEval x y (-p) = -Polynomial.evalEval x y p |
summable_pnat_iff_summable_succ | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] {f : ℕ → M},
(Summable fun x => f ↑x) ↔ Summable fun x => f (x + 1) |
CentroidHom.commRing | Mathlib.Algebra.Ring.CentroidHom | {α : Type u_5} →
[inst : NonUnitalRing α] → (∀ (a b : α), (∀ (r : α), a * r * b = 0) → a = 0 ∨ b = 0) → CommRing (CentroidHom α) |
ProbabilityTheory.HasGaussianLaw.fst | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {F : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E]
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace ℝ F] [inst_6 : MeasurableSpace F] {Y : Ω → F},
ProbabilityTheory.HasGaussianLaw (fun ω => (X ω, Y ω)) P → ProbabilityTheory.HasGaussianLaw X P |
NNRat.castHom | Mathlib.Data.Rat.Cast.CharZero | (α : Type u_3) → [inst : DivisionSemiring α] → [CharZero α] → ℚ≥0 →+* α |
CategoryTheory.Abelian.Ext.precompOfLinear._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X : C} (R : Type u_1) [inst_3 : CommRing R] [inst_4 : CategoryTheory.Linear R C]
(Z : C) {b : ℕ}, SMulCommClass R R (CategoryTheory.Abelian.Ext X Z b) |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.addUnresolvedCompletionItem | Lean.Server.Completion.CompletionCollectors | Lean.Name →
Lean.Lsp.CompletionIdentifier →
Lean.Lsp.CompletionItemKind → Array Lean.Lsp.CompletionItemTag → Lean.Server.Completion.M✝ Unit |
CategoryTheory.MorphismProperty.instCompleteBooleanAlgebra._proof_15 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.CategoryStruct.{u_1, u_2} C] (x : ⦃X Y : C⦄ → (X ⟶ Y) → Prop), ⊤ ≤ x ⊔ xᶜ |
_private.Init.Data.String.OrderInstances.0.String.Pos.Raw.instTotalLe._simp_6 | Init.Data.String.OrderInstances | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) |
ordinaryHypergeometricSeries.congr_simp | Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric | ∀ {𝕂 : Type u_1} (𝔸 : Type u_2) [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸] [inst_3 : TopologicalSpace 𝔸]
[inst_4 : IsTopologicalRing 𝔸] (a a_1 : 𝕂),
a = a_1 →
∀ (b b_1 : 𝕂),
b = b_1 →
∀ (c c_1 : 𝕂),
c = c_1 → ∀ (n : ℕ), ordinaryHypergeometricSeries 𝔸 a b c n = ordinaryHypergeometricSeries 𝔸 a_1 b_1 c_1 n |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_minKeyD._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
NormedAddGroupHom.ker.lift._proof_2 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_3} {V₂ : Type u_1} {V₃ : Type u_2} [inst : SeminormedAddCommGroup V₁]
[inst_1 : SeminormedAddCommGroup V₂] [inst_2 : SeminormedAddCommGroup V₃] (f : NormedAddGroupHom V₁ V₂)
(g : NormedAddGroupHom V₂ V₃) (h : g.comp f = 0) (v w : V₁), ⟨f (v + w), ⋯⟩ = ⟨f v, ⋯⟩ + ⟨f w, ⋯⟩ |
Lean.Server.FileWorker.PendingRequest.noConfusion | Lean.Server.FileWorker | {P : Sort u} →
{t t' : Lean.Server.FileWorker.PendingRequest} → t = t' → Lean.Server.FileWorker.PendingRequest.noConfusionType P t t' |
AddSubgroup.instNormalCenter | Mathlib.GroupTheory.Subgroup.Center | ∀ {G : Type u_1} [inst : AddGroup G], (AddSubgroup.center G).Normal |
AlgEquiv.ofRingEquiv.congr_simp | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] {f f_1 : A₁ ≃+* A₂} (e_f : f = f_1)
(hf : ∀ (x : R), f ((algebraMap R A₁) x) = (algebraMap R A₂) x), AlgEquiv.ofRingEquiv hf = AlgEquiv.ofRingEquiv ⋯ |
List.splitLengths.eq_def | Mathlib.Data.List.SplitLengths | ∀ {α : Type u_1} (x : List ℕ) (x_1 : List α),
x.splitLengths x_1 =
match x, x_1 with
| [], x => []
| n :: ns, x =>
match List.splitAt n x with
| (x0, x1) => x0 :: ns.splitLengths x1 |
LieRing.recOn | Mathlib.Algebra.Lie.Basic | {L : Type v} →
{motive : LieRing L → Sort u} →
(t : LieRing L) →
([toAddCommGroup : AddCommGroup L] →
[toBracket : Bracket L L] →
(add_lie : ∀ (x y z : L), ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆) →
(lie_add : ∀ (x y z : L), ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆) →
(lie_self : ∀ (x : L), ⁅x, x⁆ = 0) →
(leibniz_lie : ∀ (x y z : L), ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆) →
motive
{ toAddCommGroup := toAddCommGroup, toBracket := toBracket, add_lie := add_lie,
lie_add := lie_add, lie_self := lie_self, leibniz_lie := leibniz_lie }) →
motive t |
_private.Init.Data.String.Defs.0.String.Slice.Pos.byte._simp_1 | Init.Data.String.Defs | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) |
CategoryTheory.ShortComplex.SnakeInput.snd_δ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd S.L₁.g S.v₀₁.τ₃) S.δ =
CategoryTheory.CategoryStruct.comp S.φ₁ S.v₂₃.τ₁ |
OrderEmbedding.locallyFiniteOrder._proof_6 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder β] (f : α ↪o β)
(a b : α), Set.InjOn (⇑f.toEmbedding) (⇑f ⁻¹' ↑(Finset.Ico (f a) (f b))) |
PerfectionMap.id | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (R : Type u₁) [inst_1 : CommSemiring R] [inst_2 : CharP R p]
[inst_3 : PerfectRing R p], PerfectionMap p (RingHom.id R) |
Aesop.NormSeqResult.proved.noConfusion | Aesop.Search.Expansion.Norm | {P : Sort u} →
{script script' : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep))} →
Aesop.NormSeqResult.proved script = Aesop.NormSeqResult.proved script' → (script = script' → P) → P |
LightProfinite.equivDiagram | Mathlib.Topology.Category.LightProfinite.Basic | LightProfinite ≌ LightDiagram |
RelIso.trans._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_3} {β : Type u_1} {γ : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop} (f₁ : r ≃r s)
(f₂ : s ≃r t) {a b : α}, t (f₂ (f₁.toEquiv a)) (f₂ (f₁.toEquiv b)) ↔ r a b |
_private.Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski.0.AlgebraicGeometry.Scheme.AffineZariskiSite.coequifibered_iff_forall_isLocalizationAway.match_1_5 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} (x : X.AffineZariskiSiteᵒᵖ) (motive : (x_1 : X.AffineZariskiSiteᵒᵖ) → (x_1 ⟶ x) → Prop)
(x_1 : X.AffineZariskiSiteᵒᵖ) (x_2 : x_1 ⟶ x),
(∀ (V : X.AffineZariskiSite) (x : Opposite.op V ⟶ x), motive (Opposite.op V) x) → motive x_1 x_2 |
Derivation.noConfusion | Mathlib.RingTheory.Derivation.Basic | {P : Sort u} →
{R : Type u_1} →
{A : Type u_2} →
{M : Type u_3} →
{inst : CommSemiring R} →
{inst_1 : CommSemiring A} →
{inst_2 : AddCommMonoid M} →
{inst_3 : Algebra R A} →
{inst_4 : Module A M} →
{inst_5 : Module R M} →
{t : Derivation R A M} →
{R' : Type u_1} →
{A' : Type u_2} →
{M' : Type u_3} →
{inst' : CommSemiring R'} →
{inst'_1 : CommSemiring A'} →
{inst'_2 : AddCommMonoid M'} →
{inst'_3 : Algebra R' A'} →
{inst'_4 : Module A' M'} →
{inst'_5 : Module R' M'} →
{t' : Derivation R' A' M'} →
R = R' →
A = A' →
M = M' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
inst_4 ≍ inst'_4 →
inst_5 ≍ inst'_5 → t ≍ t' → Derivation.noConfusionType P t t' |
ContinuousLinearMap.mulLeftRight._proof_12 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (R : Type u_2) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R], ContinuousConstSMul 𝕜 (R →L[𝕜] R) |
HomeomorphClass.coe_coe | Mathlib.Topology.Homeomorph.Defs | ∀ {F : Type u_5} {α : Type u_6} {β : Type u_7} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : EquivLike F α β] [h : HomeomorphClass F α β] (f : F), ⇑↑f = ⇑f |
CategoryTheory.Functor.PullbackObjObj.π_iso_of_iso_left_inv | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {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₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ f₁' : CategoryTheory.Arrow C₁}
{f₃ : CategoryTheory.Arrow C₃} (sq₁₃ : G.PullbackObjObj f₁.hom f₃.hom) (sq₁₃' : G.PullbackObjObj f₁'.hom f₃.hom)
(iso : f₁ ≅ f₁'), (sq₁₃.π_iso_of_iso_left sq₁₃' iso).inv = sq₁₃'.mapArrowLeft sq₁₃ iso.hom |
Std.Roi.LawfulRcoIntersection.mk._flat_ctor | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type w} [inst : LT α] [inst_1 : LE α] [inst_2 : Std.Roi.HasRcoIntersection α],
(∀ {a : α} {r : Std.Roi α} {s : Std.Rco α}, a ∈ Std.Roi.HasRcoIntersection.intersection r s ↔ a ∈ r ∧ a ∈ s) →
Std.Roi.LawfulRcoIntersection α |
List.mapIdx.go.match_1 | Init.Data.List.MapIdx | {α : Type u_1} →
{β : Type u_2} →
(motive : List α → Array β → Sort u_3) →
(x : List α) →
(x_1 : Array β) →
((acc : Array β) → motive [] acc) →
((a : α) → (as : List α) → (acc : Array β) → motive (a :: as) acc) → motive x x_1 |
Int.lcm_dvd_lcm_mul_right_right | Init.Data.Int.Gcd | ∀ (a b c : ℤ), a.lcm b ∣ a.lcm (b * c) |
_private.Batteries.Data.Char.Basic.0.Char.any._proof_1 | Batteries.Data.Char.Basic | ∀ c < Char.max - Char.maxSurrogate, 57343 < c + 57343 + 1 ∧ c + 57343 + 1 < 1114112 |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.FirstByte.utf8ByteSize.match_1.eq_3 | Init.Data.String.Decode | ∀ (motive : ByteArray.utf8DecodeChar?.FirstByte → Sort u_1)
(h_1 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.invalid)
(h_2 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.done)
(h_3 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.oneMore)
(h_4 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.twoMore)
(h_5 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.threeMore),
(match ByteArray.utf8DecodeChar?.FirstByte.oneMore with
| ByteArray.utf8DecodeChar?.FirstByte.invalid => h_1 ()
| ByteArray.utf8DecodeChar?.FirstByte.done => h_2 ()
| ByteArray.utf8DecodeChar?.FirstByte.oneMore => h_3 ()
| ByteArray.utf8DecodeChar?.FirstByte.twoMore => h_4 ()
| ByteArray.utf8DecodeChar?.FirstByte.threeMore => h_5 ()) =
h_3 () |
lie_mem_left | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L)
(x y : L), x ∈ I → ⁅x, y⁆ ∈ I |
_private.Batteries.Logic.0.not_nonempty_pempty.match_1_1 | Batteries.Logic | ∀ (motive : Nonempty PEmpty.{u_1} → Prop) (x : Nonempty PEmpty.{u_1}), (∀ (h : PEmpty.{u_1}), motive ⋯) → motive x |
isGLB_singleton._simp_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsGLB {a} a = True |
CategoryTheory.ObjectProperty.ι_obj_lift_obj | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(P : CategoryTheory.ObjectProperty D) (F : CategoryTheory.Functor C D) (hF : ∀ (X : C), P (F.obj X)) (X : C),
P.ι.obj ((P.lift F hF).obj X) = F.obj X |
AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft_I₀ | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z),
(AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft 𝒰 f g).I₀ = 𝒰.I₀ |
Mathlib.Explode.Entry.casesOn | Mathlib.Tactic.Explode.Datatypes | {motive : Mathlib.Explode.Entry → Sort u} →
(t : Mathlib.Explode.Entry) →
((type : Lean.MessageData) →
(line : Option ℕ) →
(depth : ℕ) →
(status : Mathlib.Explode.Status) →
(thm : Lean.MessageData) →
(deps : List (Option ℕ)) →
(useAsDep : Bool) →
motive
{ type := type, line := line, depth := depth, status := status, thm := thm, deps := deps,
useAsDep := useAsDep }) →
motive t |
Algebra.Extension.h1Cotangentι_ext | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
(x y : P.H1Cotangent), ↑x = ↑y → x = y |
GenContFract.nextDen | Mathlib.Algebra.ContinuedFractions.Basic | {K : Type u_2} → [DivisionRing K] → K → K → K → K → K |
Nat.or_mod_two_eq_one | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b : ℕ}, (a ||| b) % 2 = 1 ↔ a % 2 = 1 ∨ b % 2 = 1 |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.SolverExtension.mk.injEq | Lean.Meta.Tactic.Grind.Types | ∀ {σ : Type} (id : ℕ) (mkInitial : IO σ) (internalize : Lean.Expr → Option Lean.Expr → Lean.Meta.Grind.GoalM Unit)
(newEq newDiseq : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit) (mbtc : Lean.Meta.Grind.GoalM Bool)
(action : Lean.Meta.Grind.Action) (check : Lean.Meta.Grind.GoalM Bool) (checkInv : Lean.Meta.Grind.GoalM Unit)
(id_1 : ℕ) (mkInitial_1 : IO σ) (internalize_1 : Lean.Expr → Option Lean.Expr → Lean.Meta.Grind.GoalM Unit)
(newEq_1 newDiseq_1 : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit) (mbtc_1 : Lean.Meta.Grind.GoalM Bool)
(action_1 : Lean.Meta.Grind.Action) (check_1 : Lean.Meta.Grind.GoalM Bool) (checkInv_1 : Lean.Meta.Grind.GoalM Unit),
({ id := id, mkInitial := mkInitial, internalize := internalize, newEq := newEq, newDiseq := newDiseq, mbtc := mbtc,
action := action, check := check, checkInv := checkInv } =
{ id := id_1, mkInitial := mkInitial_1, internalize := internalize_1, newEq := newEq_1, newDiseq := newDiseq_1,
mbtc := mbtc_1, action := action_1, check := check_1, checkInv := checkInv_1 }) =
(id = id_1 ∧
mkInitial = mkInitial_1 ∧
internalize = internalize_1 ∧
newEq = newEq_1 ∧
newDiseq = newDiseq_1 ∧ mbtc = mbtc_1 ∧ action = action_1 ∧ check = check_1 ∧ checkInv = checkInv_1) |
Submodule.one_mem_div._simp_1 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
{I J : Submodule R A}, (1 ∈ I / J) = (J ≤ I) |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.descFactorial_self.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x |
TensorProduct.gradedCommAux._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Graded.External | ∀ (R : Type u_1) [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) |
eventually_nhdsWithin_iff | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α} {p : α → Prop},
(∀ᶠ (x : α) in nhdsWithin a s, p x) ↔ ∀ᶠ (x : α) in nhds a, x ∈ s → p x |
Polynomial.Chebyshev.T_derivative_mem_span_T | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ {R : Type u_1} [inst : CommRing R] (n : ℕ),
Polynomial.derivative (Polynomial.Chebyshev.T R ↑n) ∈
Submodule.span ℕ ((fun m => Polynomial.Chebyshev.T R ↑m) '' Set.Ico 0 n) |
Qq.Impl.UnquoteState.exprBackSubst | Qq.Macro | Qq.Impl.UnquoteState → Std.HashMap Lean.Expr Qq.Impl.ExprBackSubstResult |
Matrix.Fin.circulant_mul_comm | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} [inst : CommMagma α] [inst_1 : AddCommMonoid α] {n : ℕ} (v w : Fin n → α),
Matrix.circulant v * Matrix.circulant w = Matrix.circulant w * Matrix.circulant v |
Fin.predAbove._proof_2 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (p : Fin n) (i : Fin (n + 1)), p.castSucc < i → i ≠ 0 |
metricSpacePi._proof_1 | Mathlib.Topology.MetricSpace.Basic | ∀ {β : Type u_1} {X : β → Type u_2} [inst : (b : β) → MetricSpace (X b)], T0Space ((i : β) → X i) |
WellFoundedLT.toOrderBot._proof_3 | Mathlib.Order.WellFounded | ∀ (α : Type u_1) [inst : LinearOrder α] [h : WellFoundedLT α] (a : α), ⋯.min Set.univ ⋯ ≤ a |
_private.Mathlib.LinearAlgebra.Dimension.Free.0.FiniteDimensional.nonempty_linearEquiv_iff_finrank_eq.match_1_1 | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u_3} {M : Type u_2} {M' : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (motive : Nonempty (M ≃ₗ[R] M') → Prop)
(x : Nonempty (M ≃ₗ[R] M')), (∀ (h : M ≃ₗ[R] M'), motive ⋯) → motive x |
Ordinal._aux_Mathlib_SetTheory_Ordinal_Veblen___macroRules_Ordinal_termε₀_1 | Mathlib.SetTheory.Ordinal.Veblen | Lean.Macro |
_private.Mathlib.Topology.IsLocalHomeomorph.0.IsLocalHomeomorphOn.discreteTopology_image_iff._simp_1_2 | Mathlib.Topology.IsLocalHomeomorph | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.mkCondChain.go._sunfold | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | {w : ℕ} → Lean.Expr → Lean.Expr → Lean.Expr → (ℕ → BitVec w) → List Lean.Expr → ℕ → Lean.Expr → Lean.MetaM Lean.Expr |
MonoidAlgebra.nonUnitalNonAssocRing._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : Mul M] (a b c : MonoidAlgebra R M),
(a + b) * c = a * c + b * c |
CentroidHom.instAddCommGroup._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (x y : CentroidHom α), (x + y).toEnd = x.toEnd + y.toEnd |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.restoreAssignments_performRupCheck_base_case._proof_1_9 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (derivedLits_arr : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(j : Fin derivedLits_arr.size), ↑j < derivedLits_arr.size |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.withInductiveLocalDecls.loop._unsafe_rec | Lean.Elab.MutualInductive | {α : Type} →
Array Lean.Elab.Command.PreElabHeaderResult →
(Array Lean.Expr → Array Lean.Expr → Lean.Elab.TermElabM α) →
Array Lean.Expr → ℕ → Array Lean.Expr → Lean.Elab.TermElabM α |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.trySynthPending | Lean.Meta.ExprDefEq | Lean.Expr → Lean.MetaM Bool |
Option.pfilter_congr | Init.Data.Option.Lemmas | ∀ {α : Type u} {o o' : Option α} (ho : o = o') {f : (a : α) → o = some a → Bool} {g : (a : α) → o' = some a → Bool},
(∀ (a : α) (ha : o' = some a), f a ⋯ = g a ha) → o.pfilter f = o'.pfilter g |
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux_map | Mathlib.CategoryTheory.Sites.CoverLifting | ∀ {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] {G : CategoryTheory.Functor C D} {A : Type w}
[inst_2 : CategoryTheory.Category.{w', w} A] {J : CategoryTheory.GrothendieckTopology C}
{K : CategoryTheory.GrothendieckTopology D} [inst_3 : G.IsCocontinuous J K] {F : CategoryTheory.Functor Cᵒᵖ A}
(hF : CategoryTheory.Presheaf.IsSheaf J F) {R : CategoryTheory.Functor Dᵒᵖ A} (α : G.op.comp R ⟶ F) {X : D}
{S : K.Cover X} (s : CategoryTheory.Limits.Multifork (S.index R)) {Y : C} (f : G.obj Y ⟶ X) {W : C} (g : W ⟶ Y)
(i : S.Arrow) (h : G.obj W ⟶ i.Y),
CategoryTheory.CategoryStruct.comp h i.f = CategoryTheory.CategoryStruct.comp (G.map g) f →
CategoryTheory.CategoryStruct.comp (CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux hF α s f) (F.map g.op) =
CategoryTheory.CategoryStruct.comp (s.ι i)
(CategoryTheory.CategoryStruct.comp (R.map h.op) (α.app (Opposite.op W))) |
MeasureTheory.ofReal_lpNorm | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f : α → E},
MeasureTheory.MemLp f p μ → ENNReal.ofReal (MeasureTheory.lpNorm f p μ) = MeasureTheory.eLpNorm f p μ |
_private.Init.Data.Nat.Lemmas.0.Nat.le_pow._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {a : ℕ} {b : ℕ}, 0 < b → ¬b = b - 1 + 1 → False |
DirectSum.sigmaCurryEquiv._proof_2 | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type u_3} [inst : DecidableEq ι] {α : ι → Type u_2} {δ : (i : ι) → α i → Type u_1}
[inst_1 : (i : ι) → (j : α i) → AddCommMonoid (δ i j)],
Function.RightInverse DFinsupp.sigmaCurryEquiv.invFun DFinsupp.sigmaCurryEquiv.toFun |
Dilation.isClosedEmbedding | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : EMetricSpace α] [inst_1 : FunLike F α β] [CompleteSpace α]
[inst_3 : EMetricSpace β] [DilationClass F α β] (f : F), Topology.IsClosedEmbedding ⇑f |
String.Slice.Pattern.Model.NoPrefixForwardPatternModel | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} → (pat : ρ) → [String.Slice.Pattern.Model.ForwardPatternModel pat] → Prop |
Finmap.lookup_union_right | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s₁ s₂ : Finmap β},
a ∉ s₁ → Finmap.lookup a (s₁ ∪ s₂) = Finmap.lookup a s₂ |
LE.rec | Init.Prelude | {α : Type u} → {motive : LE α → Sort u_1} → ((le : α → α → Prop) → motive { le := le }) → (t : LE α) → motive t |
MeasureTheory.innerRegularWRT_isCompact_isOpen | Mathlib.MeasureTheory.Measure.RegularityCompacts | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
[TopologicalSpace.IsCompletelyPseudoMetrizableSpace α] [OpensMeasurableSpace α] (P : MeasureTheory.Measure α)
[MeasureTheory.IsFiniteMeasure P], P.InnerRegularWRT IsCompact IsOpen |
initFn._@.Mathlib.Geometry.Manifold.Notation.3092023753._hygCtx._hyg.2 | Mathlib.Geometry.Manifold.Notation | IO Unit |
CompletelyDistribLattice.MinimalAxioms.ctorIdx | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → CompletelyDistribLattice.MinimalAxioms α → ℕ |
FirstOrder.Language.LHom.substructureReduct._proof_4 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : L.Structure M] {L' : FirstOrder.Language} [inst_1 : L'.Structure M]
(φ : L →ᴸ L') [inst_2 : φ.IsExpansionOn M] (S T : L'.Substructure M),
(fun S => { carrier := ↑S, fun_mem := ⋯ }) S = (fun S => { carrier := ↑S, fun_mem := ⋯ }) T → S = T |
CategoryTheory.ComposableArrows.Exact.cokerToKer'._proof_1 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {n : ℕ}
{S : CategoryTheory.ComposableArrows C (n + 3)}, S.Exact → S.IsComplex |
USize.toUInt8_ofBitVec | Init.Data.UInt.Lemmas | ∀ (b : BitVec System.Platform.numBits), { toBitVec := b }.toUInt8 = { toBitVec := BitVec.setWidth 8 b } |
ProjectiveSpectrum.mem_vanishingIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] (t : Set (ProjectiveSpectrum 𝒜)) (f : A),
f ∈ ProjectiveSpectrum.vanishingIdeal t ↔ ∀ x ∈ t, f ∈ x.asHomogeneousIdeal |
NormedAddGroupHom.opNorm_le_bound | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f : NormedAddGroupHom V₁ V₂) {M : ℝ}, 0 ≤ M → (∀ (x : V₁), ‖f x‖ ≤ M * ‖x‖) → ‖f‖ ≤ M |
List.instLawfulTraversable | Mathlib.Control.Traversable.Instances | LawfulTraversable List |
_private.Mathlib.Analysis.Convex.Side.0.AffineSubspace.isPreconnected_setOf_wOppSide._simp_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] (x y : P),
⊥.WOppSide x y = False |
Lean.Server.instInhabitedDocumentMeta.default | Lean.Server.Utils | Lean.Server.DocumentMeta |
Int16.toISize_ofIntLE | Init.Data.SInt.Lemmas | ∀ {n : ℤ} (h₁ : Int16.minValue.toInt ≤ n) (h₂ : n ≤ Int16.maxValue.toInt),
(Int16.ofIntLE n h₁ h₂).toISize = ISize.ofIntLE n ⋯ ⋯ |
Int64.toUInt64_or | Init.Data.SInt.Bitwise | ∀ (a b : Int64), (a ||| b).toUInt64 = a.toUInt64 ||| b.toUInt64 |
Finset.sum_Ioc_consecutive | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_3} [inst : AddCommMonoid M] (f : ℕ → M) {m n k : ℕ},
m ≤ n → n ≤ k → ∑ i ∈ Finset.Ioc m n, f i + ∑ i ∈ Finset.Ioc n k, f i = ∑ i ∈ Finset.Ioc m k, f i |
IntermediateField.map_sup | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type u_3}
[inst_3 : Field K] [inst_4 : Algebra F K] (s t : IntermediateField F E) (f : E →ₐ[F] K),
IntermediateField.map f (s ⊔ t) = IntermediateField.map f s ⊔ IntermediateField.map f t |
neg_lt_neg_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b : α} [AddRightStrictMono α],
-a < -b ↔ b < a |
AddSubgroup.coe_copy | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (K : AddSubgroup G) (s : Set G) (hs : s = ↑K), ↑(K.copy s hs) = s |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.