name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Int.Linear.instBEqExpr.beq.match_1 | Init.Data.Int.Linear | (motive : Int.Linear.Expr → Int.Linear.Expr → Sort u_1) →
(x x_1 : Int.Linear.Expr) →
((a b : ℤ) → motive (Int.Linear.Expr.num a) (Int.Linear.Expr.num b)) →
((a b : Int.Linear.Var) → motive (Int.Linear.Expr.var a) (Int.Linear.Expr.var b)) →
((a a_1 b b_1 : Int.Linear.Expr) → motive (a.add a_1) (b.add b_1)) →
((a a_1 b b_1 : Int.Linear.Expr) → motive (a.sub a_1) (b.sub b_1)) →
((a b : Int.Linear.Expr) → motive a.neg b.neg) →
((a : ℤ) →
(a_1 : Int.Linear.Expr) →
(b : ℤ) →
(b_1 : Int.Linear.Expr) → motive (Int.Linear.Expr.mulL a a_1) (Int.Linear.Expr.mulL b b_1)) →
((a : Int.Linear.Expr) →
(a_1 : ℤ) → (b : Int.Linear.Expr) → (b_1 : ℤ) → motive (a.mulR a_1) (b.mulR b_1)) →
((x x_2 : Int.Linear.Expr) → motive x x_2) → motive x x_1 | false |
NonUnitalAlgHomClass.toNonUnitalAlgHom | Mathlib.Algebra.Algebra.NonUnitalHom | {F : Type u_3} →
{R : Type u_4} →
[inst : Monoid R] →
{A : Type u_5} →
{B : Type u_6} →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : DistribMulAction R A] →
[inst_3 : NonUnitalNonAssocSemiring B] →
[inst_4 : DistribMulAction R B] →
[inst_5 : FunLike F A B] → [NonUnitalAlgHomClass F R A B] → F → A →ₙₐ[R] B | true |
NNRat.coe_div._simp_1 | Mathlib.Algebra.Field.Rat | ∀ (p q : ℚ≥0), ↑p / ↑q = ↑(p / q) | false |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.next.eq_1 | Batteries.Data.String.Lemmas | ∀ (s : String) (i : String.Pos.Raw), { s := s, i := i }.next = { s := s, i := String.Pos.Raw.next s i } | true |
Lean.Language.Lean.HeaderProcessedSnapshot.mk._flat_ctor | Lean.Language.Lean.Types | autoParam String Lean.Language.Snapshot.desc._autoParam →
Lean.Language.Snapshot.Diagnostics →
Option Lean.Elab.InfoTree →
Lean.TraceState →
Bool →
Lean.Language.SnapshotTask Lean.Language.SnapshotLeaf →
Option Lean.Language.Lean.HeaderProcessedState → Lean.Language.Lean.HeaderProcessedSnapshot | false |
Vector.swap_perm | Init.Data.Vector.Perm | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i j : ℕ} (h₁ : i < n) (h₂ : j < n), (xs.swap i j h₁ h₂).Perm xs | true |
CategoryTheory.Limits.pullback.congrHom_inv | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f₁ f₂ : X ⟶ Z} {g₁ g₂ : Y ⟶ Z} (h₁ : f₁ = f₂)
(h₂ : g₁ = g₂) [inst_1 : CategoryTheory.Limits.HasPullback f₁ g₁] [inst_2 : CategoryTheory.Limits.HasPullback f₂ g₂],
(CategoryTheory.Limits.pullback.congrHom h₁ h₂).inv =
CategoryTheory.Limits.pullback.map f₂ g₂ f₁ g₁ (CategoryTheory.CategoryStruct.id X)
(CategoryTheory.CategoryStruct.id Y) (CategoryTheory.CategoryStruct.id Z) ⋯ ⋯ | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.ofEpiOfIsIsoOfMono._proof_4 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₁.LeftHomologyData) [inst_2 : CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂] [inst_4 : CategoryTheory.Mono φ.τ₃],
CategoryTheory.CategoryStruct.comp h.f' (CategoryTheory.CategoryStruct.id h.K) =
CategoryTheory.CategoryStruct.comp φ.τ₁ (CategoryTheory.ShortComplex.LeftHomologyData.ofEpiOfIsIsoOfMono φ h).f' | false |
RegularExpression.deriv_star | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} [inst : DecidableEq α] (P : RegularExpression α) (a : α), P.star.deriv a = P.deriv a * P.star | true |
ModelWithCorners.continuous_toFun._autoParam | Mathlib.Geometry.Manifold.IsManifold.Basic | Lean.Syntax | false |
Lean.Elab.Tactic.Do.ProofMode.instInhabitedFocusResult | Lean.Elab.Tactic.Do.ProofMode.Focus | Inhabited Lean.Elab.Tactic.Do.ProofMode.FocusResult | true |
Filter.isBoundedUnder_le_abs | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] {f : Filter β}
{u : β → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f fun a => |u a|) ↔
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u ∧ Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f u | true |
IsSublattice.image | Mathlib.Order.SupClosed | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : Lattice α] [inst_1 : Lattice β] {s : Set α}
[inst_2 : FunLike F α β] [LatticeHomClass F α β], IsSublattice s → ∀ (f : F), IsSublattice (⇑f '' s) | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.keys_filter_key._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Lean.JsonRpc.MessageMetaData.notification.injEq | Lean.Data.JsonRpc | ∀ (method method_1 : String),
(Lean.JsonRpc.MessageMetaData.notification method = Lean.JsonRpc.MessageMetaData.notification method_1) =
(method = method_1) | true |
ProbabilityTheory.Kernel.comap_apply | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} {g : γ → α} (κ : ProbabilityTheory.Kernel α β) (hg : Measurable g) (c : γ),
(κ.comap g hg) c = κ (g c) | true |
Lean.Server.RequestCancellation.recOn | Lean.Server.RequestCancellation | {motive : Lean.Server.RequestCancellation → Sort u} → (t : Lean.Server.RequestCancellation) → motive { } → motive t | false |
Std.DTreeMap.Internal.Impl.Const.mem_alter!_of_not_compare_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k k' : α} {f : Option β → Option β},
¬compare k k' = Ordering.eq → (k' ∈ Std.DTreeMap.Internal.Impl.Const.alter! k f t ↔ k' ∈ t) | true |
LieAlgebra.SemiDirectSum.instLieRing | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → (ψ : L →ₗ⁅R⁆ LieDerivation R K K) → LieRing (K ⋊⁅ψ⁆ L) | true |
Std.DHashMap.Internal.Raw.insert_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} (h : m.WF) {a : α}
{b : β a}, m.insert a b = ↑(Std.DHashMap.Internal.Raw₀.insert ⟨m, ⋯⟩ a b) | true |
ZFSet.powersetEquiv | Mathlib.SetTheory.ZFC.Basic | (x : ZFSet.{u}) → ↥x.powerset ≃ ↑(𝒫 ↑x) | true |
_private.Mathlib.Order.RelSeries.0.RelSeries.length_ne_zero._simp_1_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {s : RelSeries r} {x : α}, (x ∈ s) = (x ∈ Set.range s.toFun) | false |
SimpleGraph.isClique_compl | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) {s : Set α}, Gᶜ.IsClique s ↔ G.IsIndepSet s | true |
CategoryTheory.AddGrpObj.neg_hom | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.AddGrpObj A] [inst_3 : CategoryTheory.AddGrpObj B] (f : A ⟶ B)
[CategoryTheory.IsAddMonHom f],
CategoryTheory.CategoryStruct.comp CategoryTheory.AddGrpObj.neg f =
CategoryTheory.CategoryStruct.comp f CategoryTheory.AddGrpObj.neg | true |
bddLat_dual_comp_forget_to_bddOrd | Mathlib.Order.Category.BddLat | BddLat.dual.comp (CategoryTheory.forget₂ BddLat BddOrd) = (CategoryTheory.forget₂ BddLat BddOrd).comp BddOrd.dual | true |
Congr!._aux_Mathlib_Tactic_CongrExclamation___elabRules_Congr!_congr!_1 | Mathlib.Tactic.CongrExclamation | Lean.Elab.Tactic.Tactic | false |
ZMod.isUnit_inv | Mathlib.Data.ZMod.Units | ∀ {m : ℕ} {n : ℤ}, IsUnit ↑n → IsUnit (↑n)⁻¹ | true |
CategoryTheory.ProjectiveResolution.instIsGECochainComplexOfNatInt | Mathlib.CategoryTheory.Abelian.Projective.Extend | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C}
(R : CategoryTheory.ProjectiveResolution X), R.cochainComplex.IsGE 0 | true |
List.isSome_max?_of_ne_nil | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Max α] {l : List α}, l ≠ [] → l.max?.isSome = true | true |
OrderType.instHAdd | Mathlib.Order.Types.Arithmetic | HAdd OrderType.{u} OrderType.{v} OrderType.{max u v} | true |
FintypeCat.toLightProfinite._proof_3 | Mathlib.Topology.Category.LightProfinite.Basic | ∀ {X Y Z : FintypeCat} (f : X ⟶ Y) (g : Y ⟶ Z),
CompHausLike.ofHom (fun X => TotallyDisconnectedSpace ↑X ∧ SecondCountableTopology ↑X)
{ toFun := ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)),
continuous_toFun := ⋯ } =
CategoryTheory.CategoryStruct.comp
(CompHausLike.ofHom (fun X => TotallyDisconnectedSpace ↑X ∧ SecondCountableTopology ↑X)
{ toFun := ⇑(CategoryTheory.ConcreteCategory.hom f), continuous_toFun := ⋯ })
(CompHausLike.ofHom (fun X => TotallyDisconnectedSpace ↑X ∧ SecondCountableTopology ↑X)
{ toFun := ⇑(CategoryTheory.ConcreteCategory.hom g), continuous_toFun := ⋯ }) | false |
Lean.Compiler.LCNF.FloatLetIn.FloatState.casesOn | Lean.Compiler.LCNF.FloatLetIn | {motive : Lean.Compiler.LCNF.FloatLetIn.FloatState → Sort u} →
(t : Lean.Compiler.LCNF.FloatLetIn.FloatState) →
((decision : Std.HashMap Lean.FVarId Lean.Compiler.LCNF.FloatLetIn.Decision) →
(newArms :
Std.HashMap Lean.Compiler.LCNF.FloatLetIn.Decision
(List (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure))) →
motive { decision := decision, newArms := newArms }) →
motive t | false |
Cardinal.toNat.eq_1 | Mathlib.Algebra.Module.SpanRank | Cardinal.toNat = ENat.toNatHom.comp ↑Cardinal.toENat | true |
Std.ExtTreeMap.mk._flat_ctor | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : autoParam (α → α → Ordering) Std.ExtTreeMap._auto_1} →
Std.ExtDTreeMap α (fun x => β) cmp → Std.ExtTreeMap α β cmp | false |
CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone_π_app_f | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra}
(c : CategoryTheory.Limits.Cone (D.comp T.forget)) (t : CategoryTheory.Limits.IsLimit c)
[inst_2 : CategoryTheory.Limits.PreservesLimit (D.comp T.forget) T.toFunctor]
[inst_3 : CategoryTheory.Limits.PreservesLimit ((D.comp T.forget).comp T.toFunctor) T.toFunctor] (j : J),
((CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone c t).π.app j).f = c.π.app j | true |
AlgHom.instContinuousLinearMapClassOfAlgHomClass | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {𝕜 : Type u_1} {A : Type u_2} {F : Type u_3} [inst : NormedField 𝕜] [inst_1 : NormedRing A]
[inst_2 : NormedAlgebra 𝕜 A] [CompleteSpace A] [inst_4 : FunLike F A 𝕜] [AlgHomClass F 𝕜 A 𝕜],
ContinuousLinearMapClass F 𝕜 A 𝕜 | true |
Lean.Meta.Grind.Arith.finalizeModel | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Meta.Grind.Goal →
(Lean.Meta.Grind.ENode → Lean.MetaM Bool) → Std.HashMap Lean.Expr ℚ → Lean.MetaM (Array (Lean.Expr × ℚ)) | true |
List.mem_sublists._simp_1 | Mathlib.Data.List.Sublists | ∀ {α : Type u} {s t : List α}, (s ∈ t.sublists) = s.Sublist t | false |
_private.Mathlib.Tactic.FunProp.Theorems.0.Mathlib.Meta.FunProp.instReprLambdaTheoremType.repr.match_1 | Mathlib.Tactic.FunProp.Theorems | (motive : Mathlib.Meta.FunProp.LambdaTheoremType → Sort u_1) →
(x : Mathlib.Meta.FunProp.LambdaTheoremType) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremType.id) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremType.const) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremType.apply) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremType.comp) →
(Unit → motive Mathlib.Meta.FunProp.LambdaTheoremType.pi) → motive x | false |
HNNExtension.NormalWord.cons._proof_3 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} {d : HNNExtension.NormalWord.TransversalPair G A B} (u : ℤˣ)
(w : HNNExtension.NormalWord d),
w.head ∈ d.set u →
(∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ HNNExtension.toSubgroup A B u → u = u') →
∀ (u_1 : ℤˣ) (g : G), (u_1, g) ∈ (u, w.head) :: w.toList → g ∈ d.set u_1 | false |
Ordnode.Sized.induction | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} {t : Ordnode α},
t.Sized →
∀ {C : Ordnode α → Prop},
C Ordnode.nil → (∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (l.node' x r)) → C t | true |
StarOrderedRing.rec | Mathlib.Algebra.Order.Star.Basic | {R : Type u_3} →
[inst : NonUnitalSemiring R] →
[inst_1 : PartialOrder R] →
[inst_2 : StarRing R] →
{motive : StarOrderedRing R → Sort u} →
((le_iff : ∀ (x y : R), x ≤ y ↔ ∃ p ∈ AddSubmonoid.closure (Set.range fun s => star s * s), y = x + p) →
motive ⋯) →
(t : StarOrderedRing R) → motive t | false |
Function.one_le_const | Mathlib.Algebra.Order.Pi | ∀ {α : Type u_2} {β : Type u_3} [inst : One α] [inst_1 : Preorder α] {a : α} [Nonempty β],
1 ≤ Function.const β a ↔ 1 ≤ a | true |
IsSemilinearSet.biInter | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} {ι : Type u_3} [inst : AddCommMonoid M] [AddMonoid.FG M] {s : Set ι} {t : ι → Set M},
s.Finite → (∀ i ∈ s, IsSemilinearSet (t i)) → IsSemilinearSet (⋂ i ∈ s, t i) | true |
Lean.Lsp.RpcConnectParams._sizeOf_1 | Lean.Data.Lsp.Extra | Lean.Lsp.RpcConnectParams → ℕ | false |
Lean.Lsp.Location.recOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.Location → Sort u} →
(t : Lean.Lsp.Location) →
((uri : Lean.Lsp.DocumentUri) → (range : Lean.Lsp.Range) → motive { uri := uri, range := range }) → motive t | false |
CategoryTheory.Limits.Cocone.ext._auto_1 | Mathlib.CategoryTheory.Limits.Cones | Lean.Syntax | false |
Lean.Server.Test.Runner.Client.instToJsonInteractiveTermGoal.toJson | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.InteractiveTermGoal → Lean.Json | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Balanced.append.match_1_31 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (b l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α) (n : ℕ)
(motive : (∃ c, (b.append (Batteries.RBNode.node Batteries.RBColor.black l v r)).Balanced c (n + 1)) → Prop)
(x : ∃ c, (b.append (Batteries.RBNode.node Batteries.RBColor.black l v r)).Balanced c (n + 1)),
(∀ (c : Batteries.RBColor) (IH : (b.append (Batteries.RBNode.node Batteries.RBColor.black l v r)).Balanced c (n + 1)),
motive ⋯) →
motive x | false |
Finset.max_empty | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α], ∅.max = ⊥ | true |
Option.pelim_congr_left | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Sort u_2} {o o' : Option α} {b : β} {f : (a : α) → a ∈ o → β} (h : o = o'),
o.pelim b f = o'.pelim b fun a ha => f a ⋯ | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int32.instUpwardEnumerable._proof_3 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int32), i.toInt + ↑n ≤ Int32.maxValueSealed✝.toInt → i.toInt + ↑n ≤ Int32.maxValue.toInt | false |
Monoid.CoprodI.lift._proof_3 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_2} {M : ι → Type u_1} [inst : (i : ι) → Monoid (M i)] {N : Type u_3} [inst_1 : Monoid N]
(fi : (i : ι) → M i →* N) (x y : FreeMonoid ((i : ι) × M i)),
Monoid.CoprodI.Rel M x y → (Con.ker (FreeMonoid.lift fun p => (fi p.fst) p.snd)) x y | false |
Setoid.instPartialOrder._proof_2 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} (x x_1 x_2 : Setoid α), x ≤ x_1 → x_1 ≤ x_2 → ∀ (x_3 x_4 : α), x x_3 x_4 → x_2 x_3 x_4 | false |
sInfHom.instPartialOrder | Mathlib.Order.Hom.CompleteLattice | {α : Type u_2} → {β : Type u_3} → [inst : InfSet α] → {x : CompleteLattice β} → PartialOrder (sInfHom α β) | true |
Subalgebra.mem_toNonUnitalSubalgebra | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {S : Subalgebra R A}
{x : A}, x ∈ S.toNonUnitalSubalgebra ↔ x ∈ S | true |
zpow_left_inj₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : LinearOrder G₀] {a b : G₀} {n : ℤ} [PosMulStrictMono G₀]
[MulPosMono G₀], 0 ≤ a → 0 ≤ b → n ≠ 0 → (a ^ n = b ^ n ↔ a = b) | true |
hasFDerivWithinAt_univ._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {f' : E →L[𝕜] F} {x : E},
HasFDerivWithinAt f f' Set.univ x = HasFDerivAt f f' x | false |
MonomialOrder.sPolynomial.eq_1 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} (m : MonomialOrder σ) {R : Type u_2} [inst : CommRing R] (f g : MvPolynomial σ R),
m.sPolynomial f g =
(MvPolynomial.monomial (m.degree g - m.degree f)) (m.leadingCoeff g) * f -
(MvPolynomial.monomial (m.degree f - m.degree g)) (m.leadingCoeff f) * g | true |
CategoryTheory.ShortComplex.RightHomologyMapData.id._proof_4 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id h.Q) h.g' =
CategoryTheory.CategoryStruct.comp h.g' (CategoryTheory.CategoryStruct.id S).τ₃ | false |
Finmap.replace._proof_1 | Mathlib.Data.Finmap | ∀ {α : Type u_1} {β : α → Type u_2} [inst : DecidableEq α] (a : α) (b : β a) (x x_1 : AList β),
x.entries.Perm x_1.entries → (AList.replace a b x).toFinmap = (AList.replace a b x_1).toFinmap | false |
RingEquiv.prodCongr | Mathlib.Algebra.Ring.Equiv | {R : Type u_7} →
{R' : Type u_8} →
{S : Type u_9} →
{S' : Type u_10} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring R'] →
[inst_2 : NonUnitalNonAssocSemiring S] →
[inst_3 : NonUnitalNonAssocSemiring S'] → R ≃+* R' → S ≃+* S' → R × S ≃+* R' × S' | true |
TopologicalSpace.Clopens.coe_disjoint | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] {s t : TopologicalSpace.Clopens α}, Disjoint ↑s ↑t ↔ Disjoint s t | true |
Aesop.RuleTacDescr.cases.elim | Aesop.RuleTac.Descr | {motive : Aesop.RuleTacDescr → Sort u} →
(t : Aesop.RuleTacDescr) →
t.ctorIdx = 3 →
((target : Aesop.CasesTarget) →
(md : Lean.Meta.TransparencyMode) →
(isRecursiveType : Bool) →
(ctorNames : Array Aesop.CtorNames) →
motive (Aesop.RuleTacDescr.cases target md isRecursiveType ctorNames)) →
motive t | false |
Lean.Doc.Parser.instReprUnorderedListType.repr | Lean.DocString.Parser | Lean.Doc.Parser.UnorderedListType → ℕ → Std.Format | true |
_private.Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four.0.CategoryTheory.Abelian.mono_of_epi_of_epi_mono'._proof_1_1 | Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four | ¬0 + 2 ≤ 2 → False | false |
lowerClosure_iUnion | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} {ι : Sort u_3} [inst : Preorder α] (f : ι → Set α), lowerClosure (⋃ i, f i) = ⨆ i, lowerClosure (f i) | true |
CategoryTheory.PreOneHypercover.inter | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
(E : CategoryTheory.PreOneHypercover S) →
(F : CategoryTheory.PreOneHypercover S) →
[∀ (i : E.I₀) (j : F.I₀), CategoryTheory.Limits.HasPullback (E.f i) (F.f j)] →
[∀ (i j : E.I₀) (k : E.I₁ i j) (a b : F.I₀) (l : F.I₁ a b),
CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (E.p₁ k) (E.f i))
(CategoryTheory.CategoryStruct.comp (F.p₁ l) (F.f a))] →
CategoryTheory.PreOneHypercover S | true |
NonemptyInterval.instLinearOrderLex | Mathlib.Order.Interval.Lex | {α : Type u_1} → [inst : LinearOrder α] → LinearOrder (Lex (NonemptyInterval α)) | true |
WithVal.ctorIdx | Mathlib.Topology.Algebra.Valued.WithVal | {R : Type u_1} →
{Γ₀ : Type u_2} →
{inst : LinearOrderedCommGroupWithZero Γ₀} → {inst_1 : Ring R} → {v : Valuation R Γ₀} → WithVal v → ℕ | false |
RelIso.default_def | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} (r : α → α → Prop), default = RelIso.refl r | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_disjoint_covering_families._simp_1_11 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | false |
Qq.Impl.MVarSynth.type.noConfusion | Qq.Macro | {P : Sort u} →
{unquotedMVar unquotedMVar' : Lean.MVarId} →
Qq.Impl.MVarSynth.type unquotedMVar = Qq.Impl.MVarSynth.type unquotedMVar' → (unquotedMVar = unquotedMVar' → P) → P | false |
CommSemigroup.noConfusion | Mathlib.Algebra.Group.Defs | {P : Sort u_1} →
{G : Type u} →
{t : CommSemigroup G} →
{G' : Type u} → {t' : CommSemigroup G'} → G = G' → t ≍ t' → CommSemigroup.noConfusionType P t t' | false |
SimpleGraph._aux_Mathlib_Combinatorics_SimpleGraph_Prod___unexpand_SimpleGraph_boxProd_1 | Mathlib.Combinatorics.SimpleGraph.Prod | Lean.PrettyPrinter.Unexpander | false |
CommMonCat.instCoeMonCat.eq_1 | Mathlib.Algebra.Category.MonCat.Basic | CommMonCat.instCoeMonCat = { coe := (CategoryTheory.forget₂ CommMonCat MonCat).obj } | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.prod_Iic_div._proof_1_16 | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_1} [inst : CommGroup M] {n : ℕ} (a : Fin n) (f : Fin (n + 1) → M),
f a.succ / f 0 = (if hi : ↑a + 1 < n + 1 then f ⟨↑a + 1, hi⟩ else 1) / if hi : 0 < n + 1 then f ⟨0, hi⟩ else 1 | false |
TensorProduct.equivOfCompatibleSMul._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_4) (S : Type u_5) (M : Type u_2) (N : Type u_3)
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N]
[inst_5 : CommSemiring A] [inst_6 : Module A M] [inst_7 : Module A N] [inst_8 : SMulCommClass R A M]
[inst_9 : CommSemiring S] [inst_10 : Module S M] [inst_11 : SMulCommClass R S M] [inst_12 : SMulCommClass A S M]
[inst_13 : TensorProduct.CompatibleSMul R A M N] [inst_14 : TensorProduct.CompatibleSMul A R M N]
(x : TensorProduct R M N),
(TensorProduct.mapOfCompatibleSMul R A S M N).toFun ((TensorProduct.mapOfCompatibleSMul A R S M N) x) = x | false |
Set.iUnion_sum | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : α ⊕ β → Set γ}, ⋃ x, s x = (⋃ x, s (Sum.inl x)) ∪ ⋃ x, s (Sum.inr x) | true |
String.Pos.utf8ByteSize_byte | Init.Data.String.Basic | ∀ {s : String} {pos : s.Pos} {h : pos ≠ s.endPos}, (pos.byte h).utf8ByteSize ⋯ = (pos.get h).utf8Size | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.maxKeyD_modify_eq_maxKeyD._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 |
CFC.nnrpow._proof_2 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : Module ℝ A] [IsScalarTower ℝ A A], IsScalarTower NNReal A A | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk._proof_7 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (k i : ℕ), i + k + 1 ≤ n → ¬i + k ≤ n → False | false |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithBot.instNoZeroDivisors._proof_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] [NoZeroDivisors α], NoZeroDivisors (WithBot α) | false |
dec_em' | Mathlib.Logic.Basic | ∀ (p : Prop) [Decidable p], ¬p ∨ p | true |
ULift.mulOneClass.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : MulOneClass α], ULift.mulOneClass = Function.Injective.mulOneClass ⇑Equiv.ulift ⋯ ⋯ ⋯ | true |
_private.Init.Data.Vector.Lemmas.0.Vector.map_inj._simp_1_3 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {a b : α} {n : ℕ}, (b ∈ Array.replicate n a) = (n ≠ 0 ∧ b = a) | false |
AddHomClass.toAddHom.congr_simp | Mathlib.Algebra.DirectSum.Module | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f f_1 : F), f = f_1 → ↑f = ↑f_1 | true |
_private.Mathlib.Algebra.Homology.Embedding.Boundary.0.ComplexShape.Embedding.not_boundaryGE_next._simp_1_2 | Mathlib.Algebra.Homology.Embedding.Boundary | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
List.allSome | Batteries.Data.List.Basic | {α : Type u_1} → List (Option α) → Option (List α) | true |
Lean.Syntax.Traverser.mk._flat_ctor | Lean.Syntax | Lean.Syntax → Array Lean.Syntax → Array ℕ → Lean.Syntax.Traverser | false |
Batteries.Tactic.Alias.AliasInfo.reverse.elim | Batteries.Tactic.Alias | {motive : Batteries.Tactic.Alias.AliasInfo → Sort u} →
(t : Batteries.Tactic.Alias.AliasInfo) →
t.ctorIdx = 2 → ((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasInfo.reverse n)) → motive t | false |
BoundedContinuousFunction.instNonUnitalNormedCommRing._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : NonUnitalNormedCommRing R]
(a b : BoundedContinuousFunction α R), a * b = b * a | false |
Lean.Compiler.LCNF.instDecidableLtPhase | Lean.Compiler.LCNF.PassManager | {p1 p2 : Lean.Compiler.LCNF.Phase} → Decidable (p1 < p2) | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processCtorAppContext.match_1 | Lean.Elab.PatternVar | (motive : Lean.BinderInfo → Sort u_1) →
(x : Lean.BinderInfo) →
(Unit → motive Lean.BinderInfo.implicit) →
(Unit → motive Lean.BinderInfo.strictImplicit) →
(Unit → motive Lean.BinderInfo.instImplicit) → ((x : Lean.BinderInfo) → motive x) → motive x | false |
AlgebraicGeometry.Scheme.AffineZariskiSite.toOpens_mono | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme}, Monotone AlgebraicGeometry.Scheme.AffineZariskiSite.toOpens | true |
AnalyticAt.eventually_analyticAt | Mathlib.Analysis.Analytic.ChangeOrigin | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [CompleteSpace F] {f : E → F}
{x : E}, AnalyticAt 𝕜 f x → ∀ᶠ (y : E) in nhds x, AnalyticAt 𝕜 f y | true |
LieSubmodule.idealizer._proof_1 | Mathlib.Algebra.Lie.Normalizer | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M) {x y : L},
x ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → y ∈ {x | ∀ (m : M), ⁅x, m⁆ ∈ N} → ∀ (m : M), ⁅x + y, m⁆ ∈ N | false |
Std.DTreeMap.Internal.Impl.insertMax | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
(k : α) → β k → (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → Std.DTreeMap.Internal.Impl.Tree α β (t.size + 1) | true |
_private.Std.Data.DTreeMap.Internal.Balanced.0.Std.DTreeMap.Internal.Impl.balancedAtRoot_one_zero._proof_1_1 | Std.Data.DTreeMap.Internal.Balanced | ¬(1 + 0 ≤ 1 ∨ 1 ≤ Std.DTreeMap.Internal.delta * 0 ∧ 0 ≤ Std.DTreeMap.Internal.delta * 1) → False | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.