name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
MonomialOrder.degree_zero | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R], m.degree 0 = 0 | true |
Homeomorph.sumComm._proof_2 | Mathlib.Topology.Constructions.SumProd | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
Continuous (Equiv.sumComm X Y).invFun | false |
max_top_left | Mathlib.Order.BoundedOrder.Lattice | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : OrderTop α] (a : α), max ⊤ a = ⊤ | true |
Module.End.HasEigenvalue.exists_hasEigenvector | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R}, f.HasEigenvalue μ → ∃ v, f.HasEigenvector μ v | true |
TrivSqZeroExt.monoid._proof_1 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Monoid R] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction R M]
[inst_3 : DistribMulAction Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M] (x y z : TrivSqZeroExt R M), x * y * z = x * (y * z) | false |
Lean.Elab.Term.Quotation.HeadCheck.ctorIdx | Lean.Elab.Quotation | Lean.Elab.Term.Quotation.HeadCheck → ℕ | false |
CategoryTheory.Square.map_f₁₃ | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D), (sq.map F).f₁₃ = F.map sq.f₁₃ | true |
ENat.toENNReal_eq_top | Mathlib.Data.Real.ENatENNReal | ∀ {n : ℕ∞}, ↑n = ⊤ ↔ n = ⊤ | true |
FirstOrder.Language.orderRel.casesOn | Mathlib.ModelTheory.Order | {motive : (a : ℕ) → FirstOrder.Language.orderRel a → Sort u} →
{a : ℕ} → (t : FirstOrder.Language.orderRel a) → motive 2 FirstOrder.Language.orderRel.le → motive a t | false |
HomologicalComplex.liftCycles_comp_homologyπ_eq_iff_up_to_refinements | Mathlib.Algebra.Homology.Refinements | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} (K : HomologicalComplex C c) (i j k : ι),
c.prev j = i →
∀ (hk : c.next j = k) {A : C} (x₂ x₂' : A ⟶ K.X j) (hx₂ : CategoryTheory.CategoryStruct.comp x₂ (K.d j k) = 0)
(hx... | true |
Lean.PersistentArray.mapMAux._unsafe_rec | Lean.Data.PersistentArray | {α : Type u} →
{m : Type u → Type v} →
[Monad m] → {β : Type u} → (α → m β) → Lean.PersistentArrayNode α → m (Lean.PersistentArrayNode β) | false |
String.isEmpty_toSlice_iff | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String}, s.toSlice.isEmpty = true ↔ s = "" | true |
PiTensorProduct.instOne | Mathlib.RingTheory.PiTensorProduct | {ι : Type u_1} →
{R : Type u_3} →
{A : ι → Type u_4} →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → AddCommMonoidWithOne (A i)] →
[inst_2 : (i : ι) → Module R (A i)] → One (PiTensorProduct R fun i => A i) | true |
WeierstrassCurve.Projective.Equation.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Projective R) (P : Fin 3 → R),
W'.Equation P = ((MvPolynomial.eval P) W'.polynomial = 0) | true |
Lean.Elab.Command.Linter.rec | Lean.Elab.Command | {motive : Lean.Linter → Sort u} →
((run : Lean.Syntax → Lean.Elab.Command.CommandElabM Unit) →
(name : Lean.Name) → motive { run := run, name := name }) →
(t : Lean.Linter) → motive t | false |
ArithmeticFunction.sigma_eq_one_iff._simp_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ (k n : ℕ), ((ArithmeticFunction.sigma k) n = 1) = (n = 1) | false |
Real.toNNReal_le_toNNReal_iff | Mathlib.Data.NNReal.Defs | ∀ {r p : ℝ}, 0 ≤ p → (r.toNNReal ≤ p.toNNReal ↔ r ≤ p) | true |
Std.Time.TimeZone.TZif.Header.mk.noConfusion | Std.Time.Zoned.Database.TzIf | {P : Sort u} →
{version : UInt8} →
{isutcnt isstdcnt leapcnt timecnt typecnt charcnt : UInt32} →
{version' : UInt8} →
{isutcnt' isstdcnt' leapcnt' timecnt' typecnt' charcnt' : UInt32} →
{ version := version, isutcnt := isutcnt, isstdcnt := isstdcnt, leapcnt := leapcnt, timecnt := timecnt,
... | false |
Set.mem_image2_of_mem | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} {γ : Type w} {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β},
a ∈ s → b ∈ t → f a b ∈ Set.image2 f s t | true |
AddMonoid.fg_range | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} [inst : AddMonoid M] {M' : Type u_3} [inst_1 : AddMonoid M'] [AddMonoid.FG M] (f : M →+ M'),
AddMonoid.FG ↥(AddMonoidHom.mrange f) | true |
Option.get_attach._proof_1 | Init.Data.Option.Attach | ∀ {α : Type u_1} {o : Option α}, o.attach.isSome = true → o.isSome = true | false |
SpectralMap.comp._proof_1 | Mathlib.Topology.Spectral.Hom | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : SpectralMap β γ) (g : SpectralMap α β),
IsSpectralMap (f.toFun ∘ ⇑g.toContinuousMap) | false |
cfcₙHomSuperset.congr_simp | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {R : Type u_1} {A : Type u_2} {p p_1 : A → Prop} (e_p : p = p_1) [inst : CommSemiring R] [inst_1 : Nontrivial R]
[inst_2 : StarRing R] [inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R]
[inst_6 : NonUnitalRing A] [inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Mo... | true |
bddAbove_Ico._simp_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, BddAbove (Set.Ico a b) = True | false |
Lean.PrettyPrinter.Delaborator.AppImplicitArg.canUnexpand | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.AppImplicitArg → Bool | true |
isCancelSMul_iff_eq_one_of_smul_eq | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : Group α] [inst_1 : MulAction α β],
IsCancelSMul α β ↔ ∀ (g : α) (x : β), g • x = x → g = 1 | true |
MonomialOrder.C_mul_leadingCoeff_monomial_degree | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] (p : MvPolynomial σ R),
MvPolynomial.C (m.leadingCoeff p) * (MvPolynomial.monomial (m.degree p)) 1 = m.leadingTerm p | true |
Finset.offDiag_inter | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} (s t : Finset α) [inst : DecidableEq α], (s ∩ t).offDiag = s.offDiag ∩ t.offDiag | true |
Std.instToStreamList | Init.Data.Stream | {α : Type u_1} → Std.ToStream (List α) (List α) | true |
NonemptyFinLinOrd.instLargeCategory._proof_8 | Mathlib.Order.Category.NonemptyFinLinOrd | autoParam
(∀ {X Y : NonemptyFinLinOrd} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | false |
CategoryTheory.Triangulated.TStructure.from_truncGE_obj_ext | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | true |
isOpen_Iio | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α] {a : α}, IsOpen (Set.Iio a) | true |
WellFounded.fixC | Init.WFComputable | {α : Sort u} →
{C : α → Sort v} → {r : α → α → Prop} → WellFounded r → ((x : α) → ((y : α) → r y x → C y) → C x) → (x : α) → C x | true |
Nat.Linear.ExprCnstr | Init.Data.Nat.Linear | Type | true |
Lean.Elab.Term.Do.ToCodeBlock.Catch.mk.inj | Lean.Elab.Do.Legacy | ∀ {x optType : Lean.Syntax} {codeBlock : Lean.Elab.Term.Do.CodeBlock} {x_1 optType_1 : Lean.Syntax}
{codeBlock_1 : Lean.Elab.Term.Do.CodeBlock},
{ x := x, optType := optType, codeBlock := codeBlock } =
{ x := x_1, optType := optType_1, codeBlock := codeBlock_1 } →
x = x_1 ∧ optType = optType_1 ∧ codeBlock... | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.take_drop._proof_1_2 | Mathlib.Data.Seq.Basic | ∀ {α : Type u_1} {s : Stream'.Seq α} {n m : ℕ} (i : ℕ),
i + 1 ≤ (List.drop m (Stream'.Seq.take n s)).length → i < (List.drop m (Stream'.Seq.take n s)).length | false |
Lean.Meta.SynthInstance.Waiter.ctorIdx | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.Waiter → ℕ | false |
BitVec.or_eq | Init.Data.BitVec.Basic | ∀ {w : ℕ} (x y : BitVec w), x.or y = x ||| y | true |
FirstOrder.ringFunc.one.sizeOf_spec | Mathlib.ModelTheory.Algebra.Ring.Basic | sizeOf FirstOrder.ringFunc.one = 1 | true |
not_irrational_zero | Mathlib.NumberTheory.Real.Irrational | ¬Irrational 0 | true |
CategoryTheory.Over.tensorHom_left_snd_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X S U : C} {R T : CategoryTheory.Over X} (fS : S ⟶ X) (fU : U ⟶ X) (f : R ⟶ CategoryTheory.Over.mk fS)
(g : T ⟶ CategoryTheory.Over.mk fU) {Z : C} (h : U ⟶ Z),
CategoryTheory.CategoryStruct.comp
(... | true |
Std.DHashMap.Internal.AssocList.instIteratorLoopAssocListIteratorIdSigmaOfMonad | Std.Data.DHashMap.Internal.AssocList.Iterator | {α : Type u} →
{β : α → Type v} →
{m : Type (max u v) → Type w''} →
[Monad m] → Std.IteratorLoop (Std.DHashMap.Internal.AssocList.AssocListIterator α β) Id m | true |
Polynomial.Chebyshev.one_le_abs_eval_T_real | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ (n : ℤ) {x : ℝ}, 1 ≤ |x| → 1 ≤ |Polynomial.eval x (Polynomial.Chebyshev.T ℝ n)| | true |
CategoryTheory.CommGrp.fullyFaithfulForget₂CommMon._proof_2 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.CommGrp C} (f : X ⟶ Y),
CategoryTheory.InducedCategory.homMk
(CategoryTheory.Grp.homMk' ((CategoryTheory.CommGrp.forget₂CommMon... | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique.0.StarAlgHom.realContinuousMapOfNNReal._simp_5 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = -b) = (a = b) | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_7.eq_1 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β)
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size r.size → Sort u_3)
(hrb : Std.DTreeMap.Internal.Impl.leaf.Balanced)
(hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond l... | true |
DiscreteMeasurableSpace.rec | Mathlib.MeasureTheory.MeasurableSpace.Defs | {α : Type u_7} →
[inst : MeasurableSpace α] →
{motive : DiscreteMeasurableSpace α → Sort u} →
((forall_measurableSet : ∀ (s : Set α), MeasurableSet s) → motive ⋯) → (t : DiscreteMeasurableSpace α) → motive t | false |
Lean.Grind.Nat.xor_congr | Init.Grind.Lemmas | ∀ {a b k₁ k₂ k : ℕ}, a = k₁ → b = k₂ → (k == k₁ ^^^ k₂) = true → a ^^^ b = k | true |
Ideal.Cotangent.lift.congr_simp | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u} [inst : CommRing R] {S : Type u_3} [inst_1 : CommRing S] [inst_2 : Algebra R S] {I : Ideal S}
{M : Type u_4} [inst_3 : AddCommGroup M] [inst_4 : Module R M] (f f_1 : ↥I →ₗ[R] M) (e_f : f = f_1)
(hf : ∀ (x y : ↥I), f (x * y) = 0), Ideal.Cotangent.lift f hf = Ideal.Cotangent.lift f_1 ⋯ | true |
ClosedSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [Group G] → [TopologicalSpace G] → Type u | true |
instHashableUInt8 | Init.Data.Hashable | Hashable UInt8 | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_278 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
Aesop.RulePatternCache.noConfusion | Aesop.RulePattern.Cache | {P : Sort u} → {t t' : Aesop.RulePatternCache} → t = t' → Aesop.RulePatternCache.noConfusionType P t t' | false |
String.Slice.Pos.offset | Init.Data.String.Defs | {s : String.Slice} → s.Pos → String.Pos.Raw | true |
_private.Mathlib.Data.Rel.0.SetRel.exists_eq_singleton_of_prod_subset_id._simp_1_3 | Mathlib.Data.Rel | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
Fin2.toFin_fs | Mathlib.Data.Fin.Fin2 | ∀ {n : ℕ} (i : Fin2 n), i.fs.toFin = i.toFin.succ | true |
Denumerable.sum._proof_4 | Mathlib.Logic.Denumerable | ∀ {α : Type u_1} {β : Type u_2} [inst : Denumerable α] [inst_1 : Denumerable β] (n : ℕ),
∃ a ∈ Encodable.decode n, Encodable.encode a = n | false |
Lean.Grind._simp_5 | Init.Grind.Norm | ∀ {n : ℤ}, (0 ∣ n) = (n = 0) | false |
Finsupp.mapDomain_injOn | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (S : Set α) {f : α → β},
Set.InjOn f S → Set.InjOn (Finsupp.mapDomain f) {w | ↑w.support ⊆ S} | true |
CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding_obj | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Functor J C)),
(CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding J C).obj P =
CategoryTheory.Idempotents.KaroubiFunctorC... | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.termS_ | Mathlib.GroupTheory.Coxeter.Inversion | Lean.ParserDescr | true |
MvPolynomial.weightedHomogeneousComponent._proof_1 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
CategoryTheory.AddMon.trivial_addMon_add | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.AddMonObj.add =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom | true |
Lean.Elab.InfoTree._sizeOf_6_eq | Lean.Elab.InfoTree.Types | ∀ (x : List Lean.Elab.InfoTree), Lean.Elab.InfoTree._sizeOf_6 x = sizeOf x | false |
groupHomology.mapCycles₂_comp_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k : Type u} [inst : CommRing k] {G H K : Type u} [inst_1 : Group G] [inst_2 : Group H] [inst_3 : Group K]
{A : Rep.{u, u, u} k G} {B : Rep.{u, u, u} k H} {C : Rep.{u, u, u} k K} (f : G →* H) (g : H →* K)
(φ : A ⟶ Rep.res f B) (ψ : B ⟶ Rep.res g C) (x : ↥(groupHomology.cycles₂ A)),
(CategoryTheory.ConcreteCateg... | true |
Field.isSeparable_sub | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {x y : E},
IsSeparable F x → IsSeparable F y → IsSeparable F (x - y) | true |
AddGroup.fg_range | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : AddGroup G] {G' : Type u_5} [inst_1 : AddGroup G'] [AddGroup.FG G] (f : G →+ G'),
AddGroup.FG ↥f.range | true |
WithZero.instGroupWithZero._proof_5 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Group α] (n : ℕ) (a : WithZero α),
DivInvMonoid.zpow (Int.negSucc n) a = (DivInvMonoid.zpow (↑n.succ) a)⁻¹ | false |
WellFounded.prod_gameAdd | Mathlib.Order.GameAdd | ∀ {α : Type u_1} {β : Type u_2} {rα : α → α → Prop} {rβ : β → β → Prop},
WellFounded rα → WellFounded rβ → WellFounded (Prod.GameAdd rα rβ) | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Pure.0.Lean.Elab.Tactic.Do.ProofMode.MGoal.pureTrivial._sparseCasesOn_1 | Lean.Elab.Tactic.Do.ProofMode.Pure | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.Environment.mk | Std.Internal.Async.System | Std.HashMap String String → Std.Internal.IO.Async.System.Environment | true |
Units.mul_inv' | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] (u : G₀ˣ), ↑u * (↑u)⁻¹ = 1 | true |
Lean.Doc.Block.ctorElimType | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
ℕ → Sort (max 1 u_1 (imax (u + 1) u_1) (imax (v + 1) (max (u + 1) (v + 1)) u_1) (imax (max (u + 1) (v + 1)) u_1)) | false |
sSupIndep.disjoint_sSup | Mathlib.Order.SupIndep | ∀ {α : Type u_1} [inst : CompleteLattice α] {s : Set α},
sSupIndep s → ∀ {x : α} {y : Set α}, x ∈ s → y ⊆ s → x ∉ y → Disjoint x (sSup y) | true |
Lean.getPPProofsThreshold | Lean.PrettyPrinter.Delaborator.Options | Lean.Options → ℕ | true |
CategoryTheory.DifferentialObject.hasZeroMorphisms._proof_4 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddMonoidWithOne S] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S]
[inst_4 : (CategoryTheory.shiftFunctor C 1).PreservesZeroMorphisms] (X : CategoryTheory.DifferentialObject S C)
{Y ... | false |
Module.End.instDivisionRing._proof_7 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : DecidableEq (Module.End R M)] [inst_4 : IsSimpleModule R M] (q : ℚ), ↑q = ↑q.num / ↑q.den | false |
Lean.Meta.Rewrite.Config.transparency | Init.Meta.Defs | Lean.Meta.Rewrite.Config → Lean.Meta.TransparencyMode | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Independent.0.AffineIndependent.vectorSpan_image_ne_of_mem_of_notMem_of_not_subsingleton._proof_1_4 | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {ι : Type u_1} {s₂ : Set ι} {i : ι} (j : ι) (fs : Finset ↑s₂),
j ∈ insert i (insert j (Finset.map (Function.Embedding.subtype fun x => x ∈ s₂) fs)) | false |
Set.countable_isTop | Mathlib.Data.Set.Countable | ∀ (α : Type u_1) [inst : PartialOrder α], {x | IsTop x}.Countable | true |
HomogeneousLocalization.Away.val_mk._proof_1 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {A : Type u_1} [inst : CommRing A] {f : A} (n : ℕ), f ^ n ∈ Submonoid.powers f | false |
CategoryTheory.Limits.BinaryBiconeMorphism.mk.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} {A B : CategoryTheory.Limits.BinaryBicone P Q} (hom hom_1 : A.pt ⟶ B.pt) (e_hom : hom = hom_1)
(wfst : CategoryTheory.CategoryStruct.comp hom B.fst = A.fst)
(wsnd : CategoryTheory.CategoryStr... | true |
CategoryTheory.Limits.DiagramOfCones.noConfusion | Mathlib.CategoryTheory.Limits.Fubini | {P : Sort u} →
{J : Type u_1} →
{K : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} J} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} K} →
{C : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} →
{F : CategoryTheory.Functor J (CategoryTheory.Func... | false |
RootPairing.Hom.mk._flat_ctor | Mathlib.LinearAlgebra.RootSystem.Hom | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{ι₂ : Type u_5} →
... | false |
Set.Finite.iSup_biInf_of_monotone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Preorder ι'] [Nonempty ι'] [IsDirectedOrder ι']
[inst_3 : Order.Frame α] {s : Set ι},
s.Finite → ∀ {f : ι → ι' → α}, (∀ i ∈ s, Monotone (f i)) → ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j | true |
Std.DTreeMap.Internal.Impl.insertMax!._f | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
(k : α) →
β k → (t : Std.DTreeMap.Internal.Impl α β) → Std.DTreeMap.Internal.Impl.below t → Std.DTreeMap.Internal.Impl α β | false |
Lean.Parser.errorAtSavedPos | Lean.Parser.Basic | String → Bool → Lean.Parser.Parser | true |
Std.ExtDHashMap.Const.get_map' | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] {f : α → β → γ} {k : α} {h' : k ∈ Std.ExtDHashMap.map f m},
Std.ExtDHashMap.Const.get (Std.ExtDHashMap.map f m) k h' = f (m.getKey k ⋯) (Std.ExtDHashMap.Const.ge... | true |
emultiplicity_zero_eq_zero_of_ne_zero | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : MonoidWithZero α] (a : α), a ≠ 0 → emultiplicity 0 a = 0 | true |
AEMeasurable.add' | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Add M] {m : MeasurableSpace α} {f g : α → M}
{μ : MeasureTheory.Measure α} [MeasurableAdd₂ M], AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (f + g) μ | true |
MeasurableEq.recOn | Mathlib.MeasureTheory.MeasurableSpace.Constructions | {α : Type u_1} →
[inst : MeasurableSpace α] →
{motive : MeasurableEq α → Sort u} →
(t : MeasurableEq α) → ((measurableSet_diagonal : MeasurableSet (Set.diagonal α)) → motive ⋯) → motive t | false |
_private.Lean.Util.CollectAxioms.0.Lean.ExportedAxiomsState.importedModuleEntries._default | Lean.Util.CollectAxioms | Array (Array (Lean.Name × Array Lean.Name)) | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Add.0.differentiableWithinAt_comp_sub._simp_1_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} {s : Set E} (a : E),
HasFDerivWithinAt (fun x => f (x - a)) f' s x = Has... | false |
lt_or_eq_or_gt_or_incompRel | Mathlib.Order.Comparable | ∀ {α : Type u_1} [inst : PartialOrder α] (a b : α), a < b ∨ a = b ∨ b < a ∨ IncompRel (fun x1 x2 => x1 ≤ x2) a b | true |
_private.Lean.Environment.0.Lean.Environment.hasUnsafe.match_1 | Lean.Environment | (motive : Option Lean.AsyncConstantInfo → Sort u_1) →
(x : Option Lean.AsyncConstantInfo) →
((cinfo : Lean.AsyncConstantInfo) → motive (some cinfo)) → (Unit → motive none) → motive x | false |
Nat.toArray_rcc_eq_singleton_append_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {xs : Array ℕ} {m n a : ℕ}, (m...=n).toArray = #[a] ++ xs ↔ m = a ∧ m ≤ n ∧ ((m + 1)...=n).toArray = xs | true |
QuadraticForm.equivalent_weightedSumSquares | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | ∀ {K : Type u_3} {V : Type u_8} [inst : Field K] [Invertible 2] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[FiniteDimensional K V] (Q : QuadraticForm K V), ∃ w, QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares K w) | true |
Mathlib.Tactic.tacticNth_grewrite_____ | Mathlib.Tactic.GRewrite.Elab | Lean.ParserDescr | true |
List.mapAccumr_eq_foldr._f | Mathlib.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} (f : α → σ → σ × β) (x : List α)
(f_1 :
List.below (motive := fun x =>
∀ (x_1 : σ),
List.mapAccumr f x x_1 =
List.foldr
(fun a s =>
have r := f a s.1;
(r.1, r.2 :: s.2))
(x_1, []) x)
x)... | false |
EuclideanGeometry.angle_le_pi_div_three_of_le_of_le | Mathlib.Geometry.Euclidean.Triangle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {p₁ p₂ p₃ : P},
EuclideanGeometry.angle p₁ p₂ p₃ ≤ EuclideanGeometry.angle p₂ p₃ p₁ →
EuclideanGeometry.angle p₁ p₂ p₃ ≤ EuclideanGeometry.angle p₃ p₁ p₂ →
... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.