name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
RightPreLieAlgebra.instLeftPreLieAlgebraMulOpposite._proof_1 | Mathlib.Algebra.NonAssoc.PreLie.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : RightPreLieRing L] [inst_2 : RightPreLieAlgebra R L],
IsScalarTower R Lᵐᵒᵖ Lᵐᵒᵖ | false |
CategoryTheory.Functor.RepresentableBy.yoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → (X : C) → (CategoryTheory.yoneda.obj X).RepresentableBy X | true |
Lean.Parser.Term.matchAltsWhereDecls.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
CategoryTheory.Localization.SmallShiftedHom.mk₀_comp_mk₀Inv | Mathlib.CategoryTheory.Localization.SmallShiftedHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W : CategoryTheory.MorphismProperty C} {M : Type w'}
[inst_1 : AddMonoid M] [inst_2 : CategoryTheory.HasShift C M] {X Y : C}
[inst_3 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M X Y]
[inst_4 : CategoryTheory.Localization.HasSmallLocaliz... | true |
Matroid.Indep.isNonloop_of_mem | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α} {I : Set α}, M.Indep I → e ∈ I → M.IsNonloop e | true |
MonoidAlgebra.liftNCRingHom_single | Mathlib.Algebra.MonoidAlgebra.Lift | ∀ {k : Type u₁} {G : Type u₂} {R : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Semiring R] (f : k →+* R)
(g : G →* R) (h_comm : ∀ (x : k) (y : G), Commute (f x) (g y)) (a : G) (b : k),
(MonoidAlgebra.liftNCRingHom f g h_comm) (MonoidAlgebra.single a b) = f b * g a | true |
AddGroupSeminorm.instSupSet._proof_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (s : Set (AddGroupSeminorm E)),
BddAbove s → ∀ (x y : E), ⨆ p, ↑p (x + y) ≤ (⨆ p, ↑p x) + ⨆ p, ↑p y | false |
CategoryTheory.Bicategory.Adjunction.homEquiv₂._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : a ⟶ b} {h : a ⟶ c}
(α : CategoryTheory.CategoryStruct.comp g l ⟶ h),
(fun γ =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight γ l)
... | false |
Turing.TM2.Stmt.ctorElim | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{motive : Turing.TM2.Stmt Γ Λ σ → Sort u} →
(ctorIdx : ℕ) →
(t : Turing.TM2.Stmt Γ Λ σ) → ctorIdx = t.ctorIdx → Turing.TM2.Stmt.ctorElimType ctorIdx → motive t | false |
SimpleGraph.isEdgeReachable_two | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V},
G.IsEdgeReachable 2 u v ↔ ∀ (e : Sym2 V), (G.deleteEdges {e}).Reachable u v | true |
LeanSearchClient.initFn._@.LeanSearchClient.LoogleSyntax.2643959438._hygCtx._hyg.2 | LeanSearchClient.LoogleSyntax | IO (IO.Ref (Std.HashMap (String × ℕ) LeanSearchClient.LoogleResult)) | false |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.embDomain_trans_apply._simp_1_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] {v : α →₀ M} {f : α → β}
{g : β → γ}, Finsupp.mapDomain g (Finsupp.mapDomain f v) = Finsupp.mapDomain (g ∘ f) v | false |
_private.Std.Data.DTreeMap.Lemmas.0.Break.runK.match_1.eq_2 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match none with
| some a => h_1 a
| none => h_2 ()) =
h_2 () | true |
CategoryTheory.sum.match_3 | Mathlib.CategoryTheory.Sums.Basic | (C : Type u_1) →
(D : Type u_2) →
(motive : C ⊕ D → Sort u_3) →
(X : C ⊕ D) → ((X : C) → motive (Sum.inl X)) → ((X : D) → motive (Sum.inr X)) → motive X | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves.0.CategoryTheory.regularTopology.equalizerCondition_w._simp_1_2 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.instMonadLiftTOptionTOfMonad_mathlib | Mathlib.Tactic.Ring.Common | {m : Type u_2 → Type u_3} →
{m' : Type u_2 → Type u_4} → [Monad m] → [Monad m'] → [MonadLiftT m m'] → MonadLiftT (OptionT m) (OptionT m') | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.isClosed_lattice._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), DiscreteTopology ↥L.lattice.toAddSubgroup | false |
List.chooseX.match_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (p : α → Prop) (l : α) (ls : List α) (x : α) (motive : x ∈ l :: ls ∧ p x → Prop)
(x_1 : x ∈ l :: ls ∧ p x), (∀ (o : x ∈ l :: ls) (h₂ : p x), motive ⋯) → motive x_1 | false |
IsGaloisGroup.fixedPoints_bot | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_4) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] [inst_5 : SMulCommClass G K L],
FixedPoints.intermediateField ↥⊥ = ⊤ | true |
exists_enorm_lt | Mathlib.Analysis.Normed.Group.Basic | ∀ (E : Type u_8) [inst : TopologicalSpace E] [inst_1 : ESeminormedAddMonoid E] [hbot : (nhdsWithin 0 {0}ᶜ).NeBot]
{c : ENNReal}, c ≠ 0 → ∃ x, x ≠ 0 ∧ ‖x‖ₑ < c | true |
CategoryTheory.Limits.biprod.braid_natural | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {W X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ W),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.map f g)
(CategoryTheory.Limits.biprod... | true |
Module.End.rTensorAlgHom._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (M : Type u_3) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], SMulCommClass R R (TensorProduct R M N) | false |
Std.Tactic.BVDecide.BVPred.ExprPair._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | SizeOf Std.Tactic.BVDecide.BVPred.ExprPair | false |
_private.Mathlib.Algebra.BigOperators.Field.0.Finset.dens_biUnion_le._simp_1_1 | Mathlib.Algebra.BigOperators.Field | ∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),
∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a | false |
SimpleGraph.Subgraph.neighborSet_subset_verts | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (G' : G.Subgraph) (v : V), G'.neighborSet v ⊆ G'.verts | true |
LieSubalgebra.coe_bracket_of_module | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (L' : LieSubalgebra R L)
{M : Type w} [inst_3 : AddCommGroup M] [inst_4 : LieRingModule L M] (x : ↥L') (m : M), ⁅x, m⁆ = ⁅↑x, m⁆ | true |
linearIndependent_algebraMap_comp_iff._simp_1 | Mathlib.LinearAlgebra.LinearIndependent.BaseChange | ∀ {ι : Type u_1} {ι' : Type u_2} [Finite ι'] {R : Type u_3} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [FaithfulSMul R S] [IsDomain S] {v : ι → ι' → R},
(LinearIndependent S fun i => ⇑(algebraMap R S) ∘ v i) = LinearIndependent R v | false |
Lean.Meta.Grind.instHashableCongrKey._private_1 | Lean.Meta.Tactic.Grind.Types | {enodeMap : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodeMap → UInt64 | false |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Cauchy.map_of_le._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {m : α → β} {m' : β → γ},
Filter.map (m' ∘ m) f = Filter.map m' (Filter.map m f) | false |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.isEagerCasesCandidate.match_1 | Lean.Meta.Tactic.Grind.Intro | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((x : Lean.Expr) → motive x) → motive x | false |
_private.Mathlib.Data.Finsupp.Weight.0.Finsupp.le_degree._simp_1_2 | Mathlib.Data.Finsupp.Weight | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : LE α] [CanonicallyOrderedAdd α] (a : α), (0 ≤ a) = True | false |
ENNReal.div_le_iff_le_mul | Mathlib.Data.ENNReal.Inv | ∀ {a b c : ENNReal}, b ≠ 0 ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ 0 → (a / b ≤ c ↔ a ≤ c * b) | true |
Std.HashMap.Raw.getElem?_diff_of_not_mem_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₁ → (m₁ \ m₂)[k]? = none | true |
CategoryTheory.Limits.pushout.desc.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPushout f g] (h h_1 : Y ⟶ W) (e_h : h = h_1) (k k_1 : Z ⟶ W) (e_k : k = k_1)
(w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k),
CategoryTheory.Limit... | true |
Std.Http.Method.acl | Std.Internal.Http.Data.Method | Std.Http.Method | true |
Quiver.Path.comp_inj' | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b c : V} {p₁ p₂ : Quiver.Path a b} {q₁ q₂ : Quiver.Path b c},
p₁.length = p₂.length → (p₁.comp q₁ = p₂.comp q₂ ↔ p₁ = p₂ ∧ q₁ = q₂) | true |
Finset.prod_coe_sort | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} (s : Finset ι) [inst : CommMonoid M] (f : ι → M), ∏ i, f ↑i = ∏ i ∈ s, f i | true |
Lean.Grind.CutsatConfig.locals._inherited_default | Init.Grind.Config | Bool | false |
CStarAlgebra.norm_le_natCast_iff_of_nonneg._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | false |
Matrix.reindex_mem_colStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {m : Type u_3} [inst_5 : Fintype m] [inst_6 : DecidableEq m]
{M : Matrix n n R} {e₁ e₂ : n ≃ m}, M ∈ Matrix.colStochastic R n → (Matrix.reindex e₁ e₂) M ∈ Matrix.col... | true |
QuadraticMap.zero_apply | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (x : M), 0 x = 0 | true |
CategoryTheory.Limits.parallelPairOpIso_inv_app_zero | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : X ⟶ Y),
(CategoryTheory.Limits.parallelPairOpIso f g).inv.app CategoryTheory.Limits.WalkingParallelPair.zero =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Limits.walkingParallelPairOpEquiv.functor.comp (CategoryTheory.Limits.... | true |
Unitary.toUnits_comp_map | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S] [inst_3 : StarMul S]
(f : R →⋆* S), Unitary.toUnits.comp (Unitary.map f).toMonoidHom = (Units.map f.toMonoidHom).comp Unitary.toUnits | true |
_private.Mathlib.Topology.Separation.CompletelyRegular.0.completelyRegularSpace_iInf._simp_1_7 | Mathlib.Topology.Separation.CompletelyRegular | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | false |
Std.Iterators.Types.ArrayIterator.stepAsHetT_iterFromIdxM | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} [LawfulMonad m] {array : Array β} {pos : ℕ},
(array.iterFromIdxM m pos).stepAsHetT =
if x : pos < array.size then pure (Std.IterStep.yield (array.iterFromIdxM m (pos + 1)) array[pos])
else pure Std.IterStep.done | true |
SimpContFract.of_isContFract | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} (v : K) [inst : Field K] [inst_1 : LinearOrder K] [inst_2 : IsStrictOrderedRing K]
[inst_3 : FloorRing K], (SimpContFract.of v).IsContFract | true |
_private.Mathlib.MeasureTheory.Measure.ProbabilityMeasure.0.MeasureTheory.ProbabilityMeasure.coeFn_univ_ne_zero._simp_1_1 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | false |
CategoryTheory.Limits.Types.limit_ext_iff | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)}
[inst_1 : CategoryTheory.Limits.HasLimit F] {x y : CategoryTheory.Limits.limit F},
x = y ↔ ∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y | true |
Tactic.ComputeAsymptotics.Seq.Stream'.dist_le_one | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (s t : Stream' α), dist s t ≤ 1 | true |
DivisionMonoid.toInvolutiveInv | Mathlib.Algebra.Group.Defs | {G : Type u} → [self : DivisionMonoid G] → InvolutiveInv G | true |
Std.Packages.PreorderOfLEArgs.mk.noConfusion | Init.Data.Order.PackageFactories | {α : Type u} →
{P : Sort u_1} →
{le : autoParam (LE α) Std.Packages.PreorderOfLEArgs.le._autoParam} →
{decidableLE : autoParam (DecidableLE α) Std.Packages.PreorderOfLEArgs.decidableLE._autoParam} →
{lt :
autoParam
(let this := le;
LT α)
Std.Pack... | false |
Field.Emb.cardinal_eq_of_isSeparable | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsSeparable F E],
Cardinal.mk (Field.Emb F E) = (fun c => if Cardinal.aleph0 ≤ c then 2 ^ c else c) (Module.rank F E) | true |
PowerSeries.exist_eq_span_eq_ncard_of_X_notMem | Mathlib.RingTheory.PowerSeries.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal (PowerSeries R)} [I.IsPrime],
PowerSeries.X ∉ I →
∀ {S : Set R},
Ideal.span S = Ideal.map PowerSeries.constantCoeff I →
S.Finite → ∃ T, I = Ideal.span T ∧ T.Finite ∧ T.ncard = S.ncard | true |
NonUnitalSubalgebraClass.nonUnitalSeminormedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {S : Type u_2} {E : Type u_1} [inst : NonUnitalSeminormedRing E] [inst_1 : SetLike S E]
[inst_2 : NonUnitalSubringClass S E] (s : S) (a b c : ↥s), (a + b) * c = a * c + b * c | false |
ProbabilityTheory.integrable_rpow_mul_cexp_of_re_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {z : ℂ},
z.re ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => ↑(X ω ^ p) * Complex.exp (z * ↑(X ω))) μ | true |
SkewMonoidAlgebra.liftNCRingHom._proof_3 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k] {R : Type u_3}
[inst_3 : Semiring R] (f : k →+* R) (g : G →* R),
(∀ {x : k} {y : G}, f (y • x) * g y = g y * f x) →
∀ (x x_1 : SkewMonoidAlgebra k G),
(SkewMonoidAlgebra.liftNC ↑f ⇑g) (x * x_1) =
... | false |
CategoryTheory.Limits.reflexivePair.mkNatIso_inv_app | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C}
(e₀ : F.obj CategoryTheory.Limits.WalkingReflexivePair.zero ≅ G.obj CategoryTheory.Limits.WalkingReflexivePair.zero)
(e₁ : F.obj CategoryTheory.Limits.WalkingReflexivePair.one ≅ G.o... | true |
Std.DTreeMap.Internal.Impl.Const.insertMany_empty_list_cons_eq_insertMany! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {k : α} {v : β} {tl : List (α × β)},
↑(Std.DTreeMap.Internal.Impl.Const.insertMany Std.DTreeMap.Internal.Impl.empty ((k, v) :: tl) ⋯) =
↑(Std.DTreeMap.Internal.Impl.Const.insertMany!
(Std.DTreeMap.Internal.Impl.insert! k v Std.DTreeMap.Internal.Impl.empty) tl) | true |
HahnSeries.SummableFamily.casesOn | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_8} →
{R : Type u_9} →
[inst : PartialOrder Γ] →
[inst_1 : AddCommMonoid R] →
{α : Type u_7} →
{motive : HahnSeries.SummableFamily Γ R α → Sort u} →
(t : HahnSeries.SummableFamily Γ R α) →
((toFun : α → HahnSeries Γ R) →
(isPWO_iUnion_... | false |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.even_pow._proof_1_2 | Mathlib.Algebra.Group.Nat.Even | ∀ {m : ℕ} (n : ℕ), (Even (m ^ n) ↔ Even m ∧ n ≠ 0) → (Even (m ^ (n + 1)) ↔ Even m ∧ ¬n + 1 = 0) | false |
Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.MonadSemiring | {P : Sort u} →
{m : Type → Type} →
{t : Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring m} →
{m' : Type → Type} →
{t' : Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring m'} →
m = m' → t ≍ t' → Lean.Meta.Grind.Arith.CommRing.MonadCommSemiring.noConfusionType P t t' | false |
Real.continuousAt_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, ContinuousAt Real.arctan x | true |
Std.TreeMap.Raw.Equiv.congr_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ t₃ : Std.TreeMap.Raw α β cmp},
t₁.Equiv t₂ → (t₁.Equiv t₃ ↔ t₂.Equiv t₃) | true |
List.Subperm.idxInj.congr_simp | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs ys : List α} (h : xs.Subperm ys) (i i_1 : Fin xs.length),
i = i_1 → h.idxInj i = h.idxInj i_1 | true |
Algebra.Generators.Hom.toAlgHom_monomial | 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 R R']
... | true |
Lean.Meta.Grind.EMatch.State.gmt | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatch.State → ℕ | true |
AlgebraicGeometry.WeaklyEtale | Mathlib.AlgebraicGeometry.Morphisms.WeaklyEtale | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.summable_jacobiTheta₂_term_iff._simp_1_2 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ {β : Type u_2} {G : Type u_4} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G] [IsTopologicalAddGroup G]
[Infinite β] [T2Space G] (a : G), (Summable fun x => a) = (a = 0) | false |
Std.Internal.List.containsKey_insertList_disj_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.containsKey k l || Std.Internal.List.containsKey k toInsert) | true |
left_mem_segment | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[ZeroLEOneClass 𝕜] [inst_4 : MulActionWithZero 𝕜 E] (x y : E), x ∈ segment 𝕜 x y | true |
CategoryTheory.yonedaMap._proof_2 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D) (X : C) ⦃X_1 Y : Cᵒᵖ⦄ (f : X_1 ⟶ Y),
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.yoneda.obj X).map f) fun f => F.map f) =
CategoryTheory.Categor... | false |
Order.Cofinal.above | Mathlib.Order.Ideal | {P : Type u_1} → [inst : Preorder P] → Order.Cofinal P → P → P | true |
Lean.Meta.Simp.Stats.recOn | Lean.Meta.Tactic.Simp.Types | {motive : Lean.Meta.Simp.Stats → Sort u} →
(t : Lean.Meta.Simp.Stats) →
((usedTheorems : Lean.Meta.Simp.UsedSimps) →
(diag : Lean.Meta.Simp.Diagnostics) → motive { usedTheorems := usedTheorems, diag := diag }) →
motive t | false |
padicValRat.div | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ}, q ≠ 0 → r ≠ 0 → padicValRat p (q / r) = padicValRat p q - padicValRat p r | true |
Set.mapsTo_univ | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.MapsTo f s Set.univ | true |
Subspace.flip_quotDualCoannihilatorToDual_bijective | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_4} {V : Type u_5} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : Subspace K (Module.Dual K V)) [FiniteDimensional K ↥W],
Function.Bijective ⇑(Submodule.quotDualCoannihilatorToDual W).flip | true |
Lean.Elab.Term.CalcStepView.mk.noConfusion | Lean.Elab.Calc | {P : Sort u} →
{ref : Lean.Syntax} →
{term proof : Lean.Term} →
{ref' : Lean.Syntax} →
{term' proof' : Lean.Term} →
{ ref := ref, term := term, proof := proof } = { ref := ref', term := term', proof := proof' } →
(ref = ref' → term = term' → proof = proof' → P) → P | false |
Int.instAdd | Init.Data.Int.Basic | Add ℤ | true |
linarithToGrindRegressions | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.Config | true |
ZLattice.comap_refl | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_1) [inst : NormedField K] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(L : Submodule ℤ E), ZLattice.comap K L 1 = L | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.isRflTheoremCore.match_1 | Lean.Meta.Tactic.Simp.SimpTheorems | (motive : Lean.ConstantInfo → Sort u_1) →
(__x : Lean.ConstantInfo) →
((info : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo info)) →
((x : Lean.ConstantInfo) → motive x) → motive __x | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_erase._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Submonoid.map._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_3} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid M), ∃ a ∈ ↑S, f a = 1 | false |
Std.DTreeMap.Raw.self_le_maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k} {fallback : α}, (cmp k ((t.insertIfNew k v).maxKeyD fallback)).isLE = true | true |
Turing.TM0.Cfg.q | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} → {Λ : Type u_2} → [inst : Inhabited Γ] → Turing.TM0.Cfg Γ Λ → Λ | true |
Lean.Name._impl.casesOn | Init.Prelude | {motive : Lean.Name._impl → Sort u} →
(t : Lean.Name._impl) →
motive Lean.Name.anonymous._impl →
((hash : UInt64) → (pre : Lean.Name) → (str : String) → motive (Lean.Name.str._impl hash pre str)) →
((hash : UInt64) → (pre : Lean.Name) → (i : ℕ) → motive (Lean.Name.num._impl hash pre i)) → motive t | false |
CategoryTheory.Limits.PullbackCone.mk._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | Lean.Syntax | false |
Polynomial.resultant_zero_right_deg | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m : ℕ), f.resultant g m 0 = g.coeff 0 ^ m | true |
SemimoduleCat.MonoidalCategory.leftUnitor_naturality | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M N : SemimoduleCat R} (f : M ⟶ N),
CategoryTheory.CategoryStruct.comp
(SemimoduleCat.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id (SemimoduleCat.of R R)) f)
(SemimoduleCat.MonoidalCategory.leftUnitor N).hom =
CategoryTheory.CategoryStruct.comp (... | true |
AddMonoidHom.exists_mrange_eq_mgraph | Mathlib.Algebra.Group.Graph | ∀ {G : Type u_1} {H : Type u_2} {I : Type u_3} [inst : AddMonoid G] [inst_1 : AddMonoid H] [inst_2 : AddMonoid I]
{f : G →+ H × I},
Function.Surjective (Prod.fst ∘ ⇑f) →
(∀ (g₁ g₂ : G), (f g₁).1 = (f g₂).1 → (f g₁).2 = (f g₂).2) → ∃ f', AddMonoidHom.mrange f = f'.mgraph | true |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Mem.congr_left.match_1_1 | Mathlib.SetTheory.ZFC.PSet | ∀ (x : PSet.{u_1}) (α : Type u_1) (A : α → PSet.{u_1}) (motive : x ∈ PSet.mk α A → Prop) (x_1 : x ∈ PSet.mk α A),
(∀ (a : (PSet.mk α A).Type) (ha : x.Equiv ((PSet.mk α A).Func a)), motive ⋯) → motive x_1 | false |
CategoryTheory.ShortComplex.leftHomologyOpIso | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) →
[inst_2 : S.HasRightHomology] → S.op.leftHomology ≅ Opposite.op S.rightHomology | true |
instIsPartialOrderLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : PartialOrder α], IsPartialOrder α fun x1 x2 => x1 ≤ x2 | true |
_private.Lean.Data.Json.Basic.0.Lean.Json.beq'._sparseCasesOn_7 | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
(t : Lean.Json) →
((elems : Array Lean.Json) → motive_1 (Lean.Json.arr elems)) →
(Nat.hasNotBit 16 t.ctorIdx → motive_1 t) → motive_1 t | false |
_private.Mathlib.RingTheory.DiscreteValuationRing.Basic.0.IsDiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.of_ufd_of_unique_irreducible._simp_1_3 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b | false |
CategoryTheory.hasExt_iff_small_ext | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C],
CategoryTheory.HasExt C ↔ ∀ (X Y : C) (n : ℕ), Small.{w', w} (CategoryTheory.Abelian.Ext X Y n) | true |
instIsInertiaFieldOfIsGaloisGroupSubtypeAlgEquivMemSubgroupInertia | Mathlib.NumberTheory.RamificationInertia.HilbertTheory | ∀ (K : Type u_2) (L : Type u_3) {B : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : CommRing B] (P : Ideal B) (E : Type u_6) [inst_4 : Field E] [inst_5 : Algebra E L]
[inst_6 : MulSemiringAction Gal(L/K) B] [h : IsGaloisGroup (↥(Ideal.inertia Gal(L/K) P)) E L], IsInertiaField K L P E | true |
AlgebraicGeometry.Scheme.Hom.normalizationObjIso_hom_val | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U : Y.Opens} (hU : AlgebraicGeometry.IsAffineOpen U),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.normalizationObjIso f hU).hom
(CommRingCat.ofHom
... | true |
_private.Lean.Environment.0.Lean.Environment.realizeValue.unsafe_15 | Lean.Environment | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → Lean.PersistentHashMap α (Task Dynamic) → NonScalar | true |
WithTop.bot_eq_coe._simp_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Bot α] {a : α}, (⊥ = ↑a) = (⊥ = a) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.