name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ProbabilityTheory.IdentDistrib.add_const | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ}
[inst_3 : Add γ] [MeasurableAdd γ],
ProbabilityTheory.IdentDistrib f g μ ν →
∀ (c : γ), Probab... | true |
Prod.fst_sInf | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : InfSet α] [inst_1 : InfSet β] (s : Set (α × β)),
(sInf s).1 = sInf (Prod.fst '' s) | true |
CategoryTheory.Limits.Cocone.fromStructuredArrow._proof_1 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor J C)
{X Y : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J)} (f : X ⟶ Y) (j : J),
CategoryTheory.CategoryStruct.comp ({ pt := X.right, ι := X.... | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex.0.SSet.stdSimplex.mem_nonDegenerate_iff_mono._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | false |
Lean.Parser.Term.namedPattern._regBuiltin.Lean.Parser.Term.namedPattern_1 | Lean.Parser.Term | IO Unit | false |
_private.Aesop.Tree.ExtractProof.0.Aesop.extractProofGoal._unsafe_rec | Aesop.Tree.ExtractProof | Lean.Environment → Aesop.Goal → Lean.MetaM Unit | false |
PadicInt.valuation | Mathlib.NumberTheory.Padics.PadicIntegers | {p : ℕ} → [hp : Fact (Nat.Prime p)] → ℤ_[p] → ℕ | true |
_private.Mathlib.Algebra.Group.Subgroup.Basic.0.Subgroup.mem_normalizer_iff_conj_image_eq._simp_1_4 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a * b⁻¹ = c) = (a = c * b) | false |
Lean.Meta.Simp.main | Lean.Meta.Tactic.Simp.Main | Lean.Expr →
Lean.Meta.Simp.Context →
optParam Lean.Meta.Simp.Stats { } →
optParam Lean.Meta.Simp.Methods { } → Lean.MetaM (Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats) | true |
MeasureTheory.Filtration.seq | Mathlib.Probability.Process.Filtration | {Ω : Type u_1} →
{ι : Type u_2} → [inst : Preorder ι] → {m : MeasurableSpace Ω} → MeasureTheory.Filtration ι m → ι → MeasurableSpace Ω | true |
Cardinal.preBeth_pos | Mathlib.SetTheory.Cardinal.Aleph | ∀ {o : Ordinal.{u_1}}, 0 < Cardinal.preBeth o ↔ 0 < o | true |
Lean.Meta.FindSplitImpl.Context.rec | Lean.Meta.Tactic.SplitIf | {motive : Lean.Meta.FindSplitImpl.Context → Sort u} →
((exceptionSet : Lean.ExprSet) →
(kind : Lean.Meta.SplitKind) → motive { exceptionSet := exceptionSet, kind := kind }) →
(t : Lean.Meta.FindSplitImpl.Context) → motive t | false |
Filter.EventuallyEq.hasLineDerivWithinAt_iff_of_mem | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {f₀ f₁ : E → F}
{f' : F} {s : Set E} {x v : E},
f₀ =ᶠ[nhdsWithin x s] f₁ → x ∈ s → (HasLineDerivWithinAt 𝕜 f₀... | true |
Circle.ofConjDivSelf_coe | Mathlib.Analysis.Complex.Circle | ∀ (z : ℂ) (hz : z ≠ 0), ↑(Circle.ofConjDivSelf z hz) = (starRingEnd ℂ) z / z | true |
Char.reduceBNe | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | Lean.Meta.Simp.DSimproc | true |
CategoryTheory.CostructuredArrow.well_copowered_costructuredArrow | Mathlib.CategoryTheory.Subobject.Comma | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor C D} {T : D} [inst_2 : CategoryTheory.LocallySmall.{w, v₁, u₁} C]
[CategoryTheory.WellPowered.{w, v₁, u₁} Cᵒᵖ] [CategoryTheory.Limits.HasFiniteColimits C]
[CategoryTh... | true |
Ordinal.bddAbove_range_add_one_iff | Mathlib.SetTheory.Ordinal.Family | ∀ {β : Type u_2} {f : β → Ordinal.{u}}, BddAbove (Set.range fun i => f i + 1) ↔ BddAbove (Set.range f) | true |
IO.FS.Stream.Buffer | Init.System.IO | Type | true |
Orientation.oangle_smul_add_right_eq_zero_or_eq_pi_iff | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V} (r : ℝ),
o.oangle x (r • x + y) = 0 ∨ o.oangle x (r • x + y) = ↑Real.pi ↔ o.oangle x y = 0 ∨ o.oangle x y = ↑Real.pi | true |
Lean.Grind.CommRing.Stepwise.unsat_eq._proof_5 | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) [Lean.Grind.IsCharP α 0]
(p : Lean.Grind.CommRing.Poly) (k : ℤ),
Lean.Grind.CommRing.Stepwise.unsat_eq_cert p k = true → Lean.Grind.CommRing.Poly.denote ctx p = 0 → False | false |
hasProd_subtype_iff_of_mulSupport_subset | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a : α} {s : Set β},
Function.mulSupport f ⊆ s → (HasProd (f ∘ Subtype.val) a ↔ HasProd f a) | true |
_private.Lean.Meta.Sym.Simp.EvalGround.0.Lean.Meta.Sym.Simp.evalUnary._sparseCasesOn_1 | Lean.Meta.Sym.Simp.EvalGround | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Valuation.RankOne.restrict_RankOne | Mathlib.RingTheory.Valuation.RankOne | {Γ₀ : Type u_2} →
[inst : LinearOrderedCommGroupWithZero Γ₀] →
(K : Type u_3) → [inst_1 : Field K] → (v : Valuation K Γ₀) → [v.RankOne] → v.restrict.RankOne | true |
OrthogonalFamily.comp | Mathlib.Analysis.InnerProductSpace.Subspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {G : ι → Type u_5} [inst_3 : (i : ι) → NormedAddCommGroup (G i)]
[inst_4 : (i : ι) → InnerProductSpace 𝕜 (G i)] {V : (i : ι) → G i →ₗᵢ[𝕜] E},
OrthogonalFamily 𝕜 G V →
∀ {... | true |
_private.Mathlib.Data.Sigma.Basic.0.Sigma.fst_surjective.match_1_1 | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_2} {β : α → Type u_1} (a : α) (motive : Nonempty (β a) → Prop) (x : Nonempty (β a)),
(∀ (b : β a), motive ⋯) → motive x | false |
Function.minimalPeriod_iterate_eq_div_gcd | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} {f : α → α} {x : α} {n : ℕ},
n ≠ 0 → Function.minimalPeriod f^[n] x = Function.minimalPeriod f x / (Function.minimalPeriod f x).gcd n | true |
instWeaklyLocallyCompactSpaceOfCompactSpace | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] [CompactSpace X], WeaklyLocallyCompactSpace X | true |
_private.Mathlib.Analysis.Analytic.Constructions.0.HasFPowerSeriesWithinOnBall.compContinuousLinearMap._simp_1_5 | Mathlib.Analysis.Analytic.Constructions | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom.coev_app | Mathlib.CategoryTheory.Monoidal.DayConvolution.Closed | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
[inst_4 : CategoryTheory.MonoidalClosed V] →
... | true |
Lean.Grind.Config.mk.noConfusion | Init.Grind.Config | {P : Sort u} →
{trace markInstances lax suggestions locals : Bool} →
{splits ematch gen instances : ℕ} →
{matchEqs splitMatch splitIte splitIndPred splitImp : Bool} →
{canonHeartbeats : ℕ} →
{ext extAll etaStruct funext lookahead verbose clean qlia mbtc zetaDelta zeta ring : Bool} →
... | false |
enorm_lt_top | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_8} [inst : NNNorm E] {x : E}, ‖x‖ₑ < ⊤ | true |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.mul_le_of_limit_aux._simp_1_1 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {α : Type u_1} (r : α → α → Prop) (p : α → Prop) {a b : Subtype p}, Subrel r p a b = r ↑a ↑b | false |
_private.Mathlib.Algebra.Polynomial.Degree.Defs.0.Polynomial.degree_pow_le_of_le._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R], (Polynomial.degree 1 ≤ 0) = True | false |
CategoryTheory.Functor.uncurry_obj_map | Mathlib.CategoryTheory.Functor.Currying | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
{E : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} E]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) {X Y : C × D} (f : X ⟶ Y),
(CategoryTheory.Functor.uncurry.obj F).map f =
... | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas.0.Nat.nthRoot.match_3.eq_3 | Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas | ∀ (motive : ℕ → ℕ → Sort u_1) (n a : ℕ) (h_1 : (x : ℕ) → motive 0 x) (h_2 : (a : ℕ) → motive 1 a)
(h_3 : (n a : ℕ) → motive n.succ.succ a),
(match n.succ.succ, a with
| 0, x => h_1 x
| 1, a => h_2 a
| n.succ.succ, a => h_3 n a) =
h_3 n a | true |
ManyOneEquiv.congr_right | Mathlib.Computability.Reduce | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable γ]
{p : α → Prop} {q : β → Prop} {r : γ → Prop}, ManyOneEquiv q r → (ManyOneEquiv p q ↔ ManyOneEquiv p r) | true |
Int16.toInt_ofBitVec | Init.Data.SInt.Lemmas | ∀ (b : BitVec 16), (Int16.ofBitVec b).toInt = b.toInt | true |
cast_heq_iff_heq._simp_1 | Mathlib.Logic.Basic | ∀ {α β γ : Sort u_1} (e : α = β) (a : α) (c : γ), (cast e a ≍ c) = (a ≍ c) | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.inl_comp_tensorHom._simp_1_5 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ {n m : ℕ} (eq : n = m) {a b : Fin n}, (Fin.cast eq a = Fin.cast eq b) = (a = b) | false |
_private.Mathlib.Data.Nat.Digits.Lemmas.0.List.fixedLengthDigits_zero._proof_1_2 | Mathlib.Data.Nat.Digits.Lemmas | ∀ {b : ℕ} (a : List ℕ), a = [] → ∀ x ∈ a, x < b | false |
Std.Sat.AIG.denote_idx_gate._proof_2 | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {start : ℕ} {lhs rhs : Std.Sat.AIG.Fanin}
{aig : Std.Sat.AIG α} {hstart : start < aig.decls.size},
aig.decls[start] = Std.Sat.AIG.Decl.gate lhs rhs → lhs.gate < aig.decls.size | false |
Std.HashMap.getKeyD_eq_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] {k fallback : α},
k ∈ m → m.getKeyD k fallback = k | true |
ContextFreeGrammar.mk._flat_ctor | Mathlib.Computability.ContextFreeGrammar | {T : Type u_1} → (NT : Type) → NT → Finset (ContextFreeRule T NT) → ContextFreeGrammar T | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.State.noConfusionType | Lean.Elab.Tactic.Induction | Sort u → Lean.Elab.Tactic.ElimApp.State✝ → Lean.Elab.Tactic.ElimApp.State✝ → Sort u | false |
Matrix.linftyOpSemiNormedRing | Mathlib.Analysis.Matrix.Normed | {n : Type u_4} → {α : Type u_5} → [Fintype n] → [SeminormedRing α] → [DecidableEq n] → SeminormedRing (Matrix n n α) | true |
ContinuousMap.instT2Space | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T2Space Y], T2Space C(X, Y) | true |
Stream'.WSeq.scanl | Mathlib.Data.WSeq.Defs | {α : Type u} → {β : Type v} → (α → β → α) → α → Stream'.WSeq β → Stream'.WSeq α | true |
AddGroupSeminorm.toSMul._proof_4 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {R : Type u_1} {E : Type u_2} [inst : AddGroup E] [inst_1 : SMul R ℝ] (r : R) (p : AddGroupSeminorm E) (x : E),
r • p (-x) = r • p x | false |
DeltaGenerated.instConcreteCategoryContinuousMapCarrierToTop._proof_5 | Mathlib.Topology.Category.DeltaGenerated | autoParam
(∀ {X Y : DeltaGenerated} (f : C(↑X.toTop, ↑Y.toTop)),
DeltaGenerated.instConcreteCategoryContinuousMapCarrierToTop._aux_1
(DeltaGenerated.instConcreteCategoryContinuousMapCarrierToTop._aux_3 f) =
f)
CategoryTheory.ConcreteCategory.hom_ofHom._autoParam | false |
Quaternion.instDistribMulAction._proof_2 | Mathlib.Algebra.Quaternion | ∀ {S : Type u_2} {R : Type u_1} [inst : CommRing R] [inst_1 : Semiring S] [inst_2 : DistribMulAction S R] (a : S)
(x y : Quaternion R), a • (x + y) = a • x + a • y | false |
Lean.Meta.Match.initFn._@.Lean.Meta.Match.Match.275925455._hygCtx._hyg.4 | Lean.Meta.Match.Match | IO (Lean.Option Bool) | false |
Ideal.zero_ne_one_of_proper | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, I ≠ ⊤ → 0 ≠ 1 | true |
_private.Std.Sat.AIG.If.0.Std.Sat.AIG.RefVec.ite.go_get_aux._proof_1_3 | Std.Sat.AIG.If | ∀ {w : ℕ}, ∀ curr ≤ w, ∀ (idx : ℕ), ¬curr < w → ¬curr = w → False | false |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Deligne.0.Complex.Gammaℝ_div_Gammaℝ_one_sub._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Gamma.Deligne | ∀ {s : ℂ}, (s.Gammaℝ = 0) = ∃ n, s = -(2 * ↑n) | false |
_private.Init.Data.String.Iterator.0.String.Legacy.Iterator.find._unary.eq_def | Init.Data.String.Iterator | ∀ (p : Char → Bool) (it : String.Legacy.Iterator),
String.Legacy.Iterator.find._unary p it =
if it.atEnd = true then it else if p it.curr = true then it else String.Legacy.Iterator.find._unary p it.next | false |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.Code.inferType.match_1.eq_6 | Lean.Compiler.LCNF.InferType | ∀ (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → Sort u_1) (type : Lean.Expr)
(h_1 :
(decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.Code.let decl k))
(h_2 :
(decl : Lean.... | true |
Lean.Widget.instTypeNameInteractiveMessage | Lean.Widget.InteractiveDiagnostic | TypeName Lean.Widget.InteractiveMessage | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_add_bot_coe._simp_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_2} {m : α → EReal} {f : Filter α}, Filter.Tendsto m f (nhds ⊥) = ∀ (x : ℝ), ∀ᶠ (a : α) in f, m a < ↑x | false |
mul_ciInf | Mathlib.Algebra.Order.Group.CompleteLattice | ∀ {ι : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : ConditionallyCompleteLattice G] [Nonempty ι] {f : ι → G}
[MulLeftMono G], BddBelow (Set.range f) → ∀ (a : G), a * ⨅ i, f i = ⨅ i, a * f i | true |
_private.Mathlib.Data.Set.Prod.0.Set.pi_eq_empty_iff._simp_1_2 | Mathlib.Data.Set.Prod | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | false |
PFunctor.Obj.inhabited | Mathlib.Data.PFunctor.Univariate.Basic | (P : PFunctor.{uA, uB}) → {α : Type v₁} → [Inhabited P.A] → [Inhabited α] → Inhabited (↑P α) | true |
Module.Relations.instQuotient._aux_1 | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u_3} → [inst : Ring A] → (relations : Module.Relations A) → A → relations.Quotient → relations.Quotient | false |
SubmodulesBasis.mk | Mathlib.Topology.Algebra.Nonarchimedean.Bases | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommRing R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : TopologicalSpace R] {B : ι → Submodule R M},
(∀ (i j : ι), ∃ k, B k ≤ B i ⊓ B j) → (∀ (m : M) (i : ι), ∀ᶠ (a : R) in nhds 0, a • m ∈ B i) → SubmodulesBasis B | true |
BooleanSubalgebra.instInf._proof_3 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (L M : BooleanSubalgebra α) {a : α}, a ∈ ↑L ∩ ↑M → aᶜ ∈ ↑L ∧ aᶜ ∈ ↑M | false |
Complex.zero_re | Mathlib.Data.Complex.Basic | Complex.re 0 = 0 | true |
NormedField.exists_nnnorm_lt | Mathlib.Analysis.Normed.Field.Basic | ∀ (α : Type u_2) [inst : NontriviallyNormedField α] {r : NNReal}, 0 < r → ∃ x, 0 < ‖x‖₊ ∧ ‖x‖₊ < r | true |
Aesop.CasesTarget.patterns.elim | Aesop.RuleTac.Basic | {motive : Aesop.CasesTarget → Sort u} →
(t : Aesop.CasesTarget) →
t.ctorIdx = 1 → ((patterns : Array Aesop.CasesPattern) → motive (Aesop.CasesTarget.patterns patterns)) → motive t | false |
Lean.Firefox.instFromJsonCategory | Lean.Util.Profiler | Lean.FromJson Lean.Firefox.Category | true |
Mathlib.Tactic.Module.qNF.toNF | Mathlib.Tactic.Module | {u v : Lean.Level} →
{M : Q(Type v)} → {R : Q(Type u)} → Mathlib.Tactic.Module.qNF R M → Q(Mathlib.Tactic.Module.NF «$R» «$M») | true |
ContinuousAlternatingMap.instNeg._proof_1 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_4} {M : Type u_1} {N : Type u_3} {ι : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommGroup N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] (f : M [⋀^ι]→L[R] N) (v : ι → M) (i j : ι),
v i = v j → i ≠ j → (↑(-f.toAlternat... | false |
CategoryTheory.MonoidalCategory.triangle_assoc_comp_right_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X (CategoryTheory.MonoidalCategoryStruct.t... | true |
_private.Aesop.Util.UnionFind.0.Aesop.UnionFind.sets.match_1 | Aesop.Util.UnionFind | {α : Type u_1} →
(motive : Option (Array α) → Sort u_2) →
(x : Option (Array α)) → ((set : Array α) → motive (some set)) → (Unit → motive none) → motive x | false |
Fin.succAbove_lt_succAbove_iff | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} {p : Fin (n + 1)} {i j : Fin n}, p.succAbove i < p.succAbove j ↔ i < j | true |
Int.neg_ofNat_eq_negSucc_add_one_iff | Init.Data.Int.Lemmas | ∀ {a b : ℕ}, -↑a = Int.negSucc b + 1 ↔ a = b | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema.0.Polynomial.Chebyshev.isLocalExtr_T_real_iff._proof_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ {n : ℕ}, 2 ≤ n → ↑n - 1 = ↑(n - 1) | false |
_private.Mathlib.Order.BooleanGenerators.0.IsCompactlyGenerated.BooleanGenerators.atomistic._simp_1_1 | Mathlib.Order.BooleanGenerators | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (↑s₁ ⊆ ↑s₂) = (s₁ ⊆ s₂) | false |
Lean.NameMap.instForInProdNameOfMonad | Lean.Data.NameMap.Basic | {α : Type} → {m : Type u_1 → Type u_2} → [Monad m] → ForIn m (Lean.NameMap α) (Lean.Name × α) | true |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj.presheafObj_condition | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} A]
(data : (X ... | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt.0.Lean.Meta.Grind.Arith.Cutsat.ToIntThms.mkResult.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((b' h₂ : Lean.Expr) → motive (b', h₂)) → motive x | false |
Ideal.instIsTwoSidedJacobson | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} [I.IsTwoSided], I.jacobson.IsTwoSided | true |
MonomialOrder.degree_sPolynomial | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommRing R] (f g : MvPolynomial σ R),
m.toSyn (m.degree (m.sPolynomial f g)) < m.toSyn (m.degree f ⊔ m.degree g) ∨ m.sPolynomial f g = 0 | true |
Module.supportDim_le_supportDim_quotSMulTop_succ | Mathlib.RingTheory.KrullDimension.Regular | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] {M : Type u_2} [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[Module.Finite R M] [inst_5 : IsLocalRing R] {x : R},
x ∈ IsLocalRing.maximalIdeal R → Module.supportDim R M ≤ Module.supportDim R (QuotSMulTop x M) + 1 | true |
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.exists_measurable_supersets_limRatio._simp_1_4 | Mathlib.MeasureTheory.Covering.Differentiation | (¬False) = True | false |
Std.TreeSet.Raw.foldl_eq_foldl_toList | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} {δ : Type w} {f : δ → α → δ} {init : δ},
Std.TreeSet.Raw.foldl f init t = List.foldl f init t.toList | true |
AlgEquiv.map_det | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] {S : Type w}
[inst_3 : CommRing S] [inst_4 : Algebra R S] {T : Type z} [inst_5 : CommRing T] [inst_6 : Algebra R T] (f : S ≃ₐ[R] T)
(M : Matrix n n S), f M.det = (f.mapMatrix M).det | true |
intervalIntegral.intervalIntegrable_const | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {a b c : ℝ} {μ : MeasureTheory.Measure ℝ} [MeasureTheory.IsLocallyFiniteMeasure μ],
IntervalIntegrable (fun x => c) μ a b | true |
CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.instRingEmbeddingRing._proof_27 | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_1} [inst_1 : CategoryTheory.SmallCategory D]
(F : CategoryTheory.Functor D Cᵒᵖ) [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.IsGrothendieckAbelian.{u_1, u_1, u_2} C],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOn... | false |
Std.ExtDTreeMap.pliftOn | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
{γ : Sort w} →
(t : Std.ExtDTreeMap α β cmp) →
(f : (x : Std.DTreeMap α β cmp) → t = Std.ExtDTreeMap.mk x → γ) →
(∀ (a b : Std.DTreeMap α β cmp) (h₁ : t = Std.ExtDTreeMap.mk a) (h₂ : t = Std.ExtDTreeMap.mk b),
... | true |
NumberField.mixedEmbedding.instIsAddHaarMeasureRealMixedSpaceVolume | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K], MeasureTheory.volume.IsAddHaarMeasure | true |
Antitone.ciInf_comp_tendsto_atTop_of_linearOrder | Mathlib.Order.Filter.AtTopBot.CompleteLattice | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : ConditionallyCompleteLinearOrder γ]
{l : Filter α} [l.NeBot] {f : β → γ},
Antitone f → ∀ {g : α → β}, Filter.Tendsto g l Filter.atTop → ⨅ a, f (g a) = ⨅ b, f b | true |
_private.Mathlib.Data.Num.Lemmas.0.Num.add_to_nat.match_1_1 | Mathlib.Data.Num.Lemmas | ∀ (motive : Num → Num → Prop) (x x_1 : Num),
(∀ (a : Unit), motive Num.zero Num.zero) →
(∀ (_q : PosNum), motive Num.zero (Num.pos _q)) →
(∀ (_p : PosNum), motive (Num.pos _p) Num.zero) →
(∀ (_p _q : PosNum), motive (Num.pos _p) (Num.pos _q)) → motive x x_1 | false |
Lean.Elab.Term.CollectPatternVars.Context.args | Lean.Elab.PatternVar | Lean.Elab.Term.CollectPatternVars.Context → List Lean.Elab.Term.Arg | true |
Lean.Grind.CommRing.Power.varLt | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Power → Lean.Grind.CommRing.Power → Bool | true |
Submonoid.LocalizationMap.lift_mul_left | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : ↥S), IsUnit (g ↑y)) (z : N),
g ↑(f.sec z).2 * (f.lift hg) z = g (f.sec z).1 | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.ι_π | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [inst_2 : CategoryTheory.EnoughInjectives C] (n : ℤ),
CategoryTheory.CategoryStruct.comp (CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.ι✝ f n)
(CochainComplex.Pl... | true |
DiscreteMeasurableSpace.forall_measurableSet | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_7} {inst : MeasurableSpace α} [self : DiscreteMeasurableSpace α] (s : Set α), MeasurableSet s | true |
AddMonCat.hom_neg_apply | Mathlib.Algebra.Category.MonCat.Basic | ∀ {M N : AddMonCat} (e : M ≅ N) (s : ↑N),
(CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) s) = s | true |
derangements.derangementsOptionEquivSigmaAtMostOneFixedPoint | Mathlib.Combinatorics.Derangements.Basic | {α : Type u_1} → [DecidableEq α] → ↑(derangements (Option α)) ≃ (a : α) × ↑{f | Function.fixedPoints ⇑f ⊆ {a}} | true |
Lean.Name.hasNum | Lean.Data.Name | Lean.Name → Bool | true |
CategoryTheory.Limits.WidePushoutShape.hom_id | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} (X : CategoryTheory.Limits.WidePushoutShape J),
CategoryTheory.Limits.WidePushoutShape.Hom.id X = CategoryTheory.CategoryStruct.id X | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.