name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Analysis.CStarAlgebra.Unitary.Connected.0.expUnitary_argSelfAdjoint._simp_1_1 | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | NormedSpace.exp = Complex.exp | false |
Lean.Parser.instCoeParserParserAliasValue | Lean.Parser.Extension | Coe Lean.Parser.Parser Lean.Parser.ParserAliasValue | true |
OpenPartialHomeomorph.trans._proof_2 | Mathlib.Topology.OpenPartialHomeomorph.Composition | ∀ {X : Type u_2} {Y : Type u_1} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (e : OpenPartialHomeomorph X Y) (e' : OpenPartialHomeomorph Y Z),
(e.symm.restrOpen e'.source ⋯).symm.target = (e'.restrOpen e.target ⋯).source | false |
isClosed_sUnion | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {S : Set (Set α)},
(∀ s ∈ S, IsClosed s) → IsClosed (⋃₀ S) | true |
CategoryTheory.Functor.whiskeringRight._proof_6 | Mathlib.CategoryTheory.Whiskering | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_4, u_1} C] (D : Type u_6)
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (E : Type u_3) [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
{X Y : CategoryTheory.Functor D E} (τ : X ⟶ Y) (X_1 Y_1 : CategoryTheory.Functor C D) (f : X_1 ⟶ Y_1),
CategoryTheory.Categor... | false |
String.Slice.Pattern.Model.Char.isLongestMatch_iff | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestMatch c pos ↔
∃ (h : s.startPos ≠ s.endPos), pos = s.startPos.next h ∧ s.startPos.get h = c | true |
Std.Sat.AIG.RefVec.map.go_decl_eq._unary | Std.Sat.AIG.RefVecOperator.Map | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ}
(f : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref f] [inst_3 : Std.Sat.AIG.RefVec.LawfulMapOperator α f]
(_x : (aig : Std.Sat.AIG α) ×' (i : ℕ) ×' (_ : i ≤ len) ×' (_ : aig.Ref... | false |
BooleanSubalgebra.rec | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} →
[inst : BooleanAlgebra α] →
{motive : BooleanSubalgebra α → Sort u} →
((toSublattice : Sublattice α) →
(compl_mem' : ∀ {a : α}, a ∈ toSublattice.carrier → aᶜ ∈ toSublattice.carrier) →
(bot_mem' : ⊥ ∈ toSublattice.carrier) →
motive { toSublattice := toSubl... | false |
Nat.log_monotone | Mathlib.Data.Nat.Log | ∀ {b : ℕ}, Monotone (Nat.log b) | true |
Lean.Lsp.instFromJsonSemanticTokenModifier | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SemanticTokenModifier | true |
StarMulEquiv.ext_iff | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} {B : Type u_3} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Star A] [inst_3 : Star B] {f g : A ≃⋆* B},
f = g ↔ ∀ (a : A), f a = g a | true |
Qq.QuotedDefEq | Qq.Typ | {u : Lean.Level} → {α : Q(Sort u)} → Q(«$α») → Q(«$α») → Prop | true |
gc_sdiff_sup | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a : α}, GaloisConnection (fun x => x \ a) fun x => a ⊔ x | true |
intervalIntegral.norm_integral_min_max | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
(f : ℝ → E), ‖∫ (x : ℝ) in min a b..max a b, f x ∂μ‖ = ‖∫ (x : ℝ) in a..b, f x ∂μ‖ | true |
MvPolynomial.IsWeightedHomogeneous | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | {R : Type u_1} →
{M : Type u_2} → [inst : CommSemiring R] → {σ : Type u_3} → [AddCommMonoid M] → (σ → M) → MvPolynomial σ R → M → Prop | true |
Behrend.ceil_lt_mul | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {x : ℝ}, 50 / 19 ≤ x → ↑⌈x⌉₊ < 1.38 * x | true |
_private.Mathlib.Data.List.Defs.0.List.length_mapAccumr.match_1_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_3} {β : Type u_2} {γ : Type u_1} (motive : (α → γ → γ × β) → List α → γ → Prop) (x : α → γ → γ × β)
(x_1 : List α) (x_2 : γ),
(∀ (f : α → γ → γ × β) (head : α) (x : List α) (s : γ), motive f (head :: x) s) →
(∀ (x : α → γ → γ × β) (x_3 : γ), motive x [] x_3) → motive x x_1 x_2 | false |
Lean.Doc.CodeBlockSuggestion.casesOn | Lean.Elab.DocString | {motive : Lean.Doc.CodeBlockSuggestion → Sort u} →
(t : Lean.Doc.CodeBlockSuggestion) →
((name : Lean.Name) →
(args moreInfo : Option String) → motive { name := name, args := args, moreInfo := moreInfo }) →
motive t | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.elabNoMatch.loop._sunfold | Lean.Elab.Match | Lean.Syntax → List Lean.Term → Array Lean.Syntax → Lean.Elab.TermElabM Lean.Term | false |
PowerSeries.hasEvalIdeal.eq_1 | Mathlib.RingTheory.PowerSeries.Evaluation | ∀ {S : Type u_2} [inst : CommRing S] [inst_1 : TopologicalSpace S] [inst_2 : IsTopologicalRing S]
[inst_3 : IsLinearTopology S S],
PowerSeries.hasEvalIdeal = { carrier := {a | PowerSeries.HasEval a}, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ } | true |
CategoryTheory.ObjectProperty.limitsClosure_top | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type t} (J : α → Type u')
[inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)], ⊤.limitsClosure J = ⊤ | true |
Mathlib.Tactic.Order.ToInt.toInt_nlt_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j : Fin n),
¬Mathlib.Tactic.Order.ToInt.toInt val i < Mathlib.Tactic.Order.ToInt.toInt val j ↔ ¬val i < val j | true |
Rep.quotientToInvariantsFunctor._proof_4 | Mathlib.RepresentationTheory.Invariants | ∀ (k : Type u_3) {G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal]
{X Y : Rep.{u_2, u_3, u_1} k G} (f : X ⟶ Y) (g : G ⧸ S),
ModuleCat.Hom.hom ((Rep.invariantsFunctor k ↥S).map ((Rep.resFunctor S.subtype).map f)) ∘ₗ
(X.ρ.quotientToInvariants S) g =
(Y.ρ.quotientToIn... | false |
BitVec.getLsbD_reverse | Init.Data.BitVec.Lemmas | ∀ {w i : ℕ} {x : BitVec w}, x.reverse.getLsbD i = x.getMsbD i | true |
IsSymmetricAlgebra.lift_eq | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {A : Type u_3}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] {f : M →ₗ[R] A} (h : IsSymmetricAlgebra f) {A' : Type u_4}
[inst_5 : CommSemiring A'] [inst_6 : Algebra R A'] (g : M →ₗ[R] A') (a : M), (h.lift g) ... | true |
HahnSeries.instLinearOrderLex | Mathlib.RingTheory.HahnSeries.Lex | {Γ : Type u_1} →
{R : Type u_2} → [inst : LinearOrder Γ] → [inst_1 : Zero R] → [LinearOrder R] → LinearOrder (Lex (HahnSeries Γ R)) | true |
LinearIsometryEquiv._sizeOf_inst | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{inst : Semiring R} →
{inst_1 : Semiring R₂} →
(σ₁₂ : R →+* R₂) →
{σ₂₁ : R₂ →+* R} →
{inst_2 : RingHomInvPair σ₁₂ σ₂₁} →
{inst_3 : RingHomInvPair σ₂₁ σ₁₂} →
(E : Type u_11) →
(E₂ : Type u_12) →
... | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.sum_Icc_sub._proof_1_11 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ} {b : Fin n}, ↑b + 1 < n + 1 | false |
MulOpposite.op_le_op._simp_2 | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (MulOpposite.op a ≤ MulOpposite.op b) = (a ≤ b) | false |
Lean.Parser.Term.showTermElabImpl._regBuiltin.Lean.Parser.Term.showTermElabImpl.formatter_9 | Lean.Parser.Term | IO Unit | false |
Std.TreeSet._sizeOf_inst | Std.Data.TreeSet.Basic | (α : Type u) → (cmp : autoParam (α → α → Ordering) Std.TreeSet._auto_1) → [SizeOf α] → SizeOf (Std.TreeSet α cmp) | false |
ContinuousMap.instNorm | Mathlib.Topology.ContinuousMap.Compact | {α : Type u_1} →
{E : Type u_3} → [inst : TopologicalSpace α] → [CompactSpace α] → [inst_2 : SeminormedAddCommGroup E] → Norm C(α, E) | true |
neg_sub_neg | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -a - -b = b - a | true |
LineDeriv.iteratedLineDerivOp_fin_zero | Mathlib.Analysis.Distribution.DerivNotation | ∀ {V : Type u_11} {E : Type u_12} [inst : LineDeriv V E E] (m : Fin 0 → V) (f : E),
LineDeriv.iteratedLineDerivOp m f = f | true |
_private.Mathlib.LinearAlgebra.Span.Defs.0.Submodule.mem_sSup_of_directed._simp_1_1 | Mathlib.LinearAlgebra.Span.Defs | ∀ {α : Type u} {s : Set α} {p : ↑s → Prop}, (∃ x, p x) = ∃ x, ∃ (h : x ∈ s), p ⟨x, h⟩ | false |
MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_Bochner_Basic___macroRules_MeasureTheory_term∫_,_∂__1» | Mathlib.MeasureTheory.Integral.Bochner.Basic | Lean.Macro | false |
Std.DTreeMap.get?_inter_of_not_mem_left | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α}, k ∉ t₁ → (t₁ ∩ t₂).get? k = none | true |
MeasureTheory.Integrable.comp_snd_iff | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν]
[MeasureTheory.IsFiniteMeasure μ] {f : β → E},
μ ≠ 0 → (MeasureTheory.Integrable (fun x => f ... | true |
Multiset.chooseX | Mathlib.Data.Multiset.Basic | {α : Type u_1} → (p : α → Prop) → [DecidablePred p] → (l : Multiset α) → (∃! a, a ∈ l ∧ p a) → { a // a ∈ l ∧ p a } | true |
ExtremallyDisconnected.open_closure | Mathlib.Topology.ExtremallyDisconnected | ∀ {X : Type u} {inst : TopologicalSpace X} [self : ExtremallyDisconnected X] (U : Set X), IsOpen U → IsOpen (closure U) | true |
_private.Mathlib.Tactic.Linter.EmptyLine.0.Mathlib.Linter.EmptyLine.emptyLineLinter.match_1 | Mathlib.Tactic.Linter.EmptyLine | (motive : Lean.MessageSeverity → Sort u_1) →
(x : Lean.MessageSeverity) →
(Unit → motive Lean.MessageSeverity.information) → ((x : Lean.MessageSeverity) → motive x) → motive x | false |
Lean.Lsp.FileEvent | Lean.Data.Lsp.Workspace | Type | true |
CategoryTheory.Limits.isoBiprodZero_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (hY : CategoryTheory.Limits.IsZero Y),
(CategoryTheory.Limits.isoBiprodZero hY).inv = CategoryTheory.Limits.biprod.fst | true |
IsometryEquiv.divRight_toEquiv | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricSMul Gᵐᵒᵖ G] (c : G),
(IsometryEquiv.divRight c).toEquiv = Equiv.divRight c | true |
Matroid.isRkFinite_iff_exists_isBasis' | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X : Set α}, M.IsRkFinite X ↔ ∃ I, M.IsBasis' I X ∧ I.Finite | true |
Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig → Sort u} →
(t : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig) →
((w : ℕ) → (vec : aig.BinaryRefVec w) → (cin : aig.Ref... | false |
Std.DHashMap.Internal.Raw₀.wfImp_insertMany | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {ρ : Type w}
[inst_4 : ForIn Id ρ ((a : α) × β a)] {m : Std.DHashMap.Internal.Raw₀ α β} {l : ρ},
Std.DHashMap.Internal.Raw.WFImp ↑m → Std.DHashMap.Internal.Raw.WFImp ↑↑(m.insertMany l) | true |
Field.Emb.Cardinal.succEquiv._proof_7 | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E]
(i : (Module.rank F E).ord.ToType),
IsScalarTower F
(↥(IntermediateField.adjoin F
(⇑(Field.Emb.Cardinal.wellOrderedBasis F... | false |
RelHom.id_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} (r : α → α → Prop) (x : α), (RelHom.id r) x = x | true |
Cardinal.nat_le_lift_iff._simp_1 | Mathlib.SetTheory.Cardinal.Order | ∀ {n : ℕ} {a : Cardinal.{u}}, (↑n ≤ Cardinal.lift.{v, u} a) = (↑n ≤ a) | false |
MvPFunctor.WPath._sizeOf_inst | Mathlib.Data.PFunctor.Multivariate.W | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → (a : P.last.W) → (a_1 : Fin2 n) → SizeOf (P.WPath a a_1) | false |
CategoryTheory.Pi.laxMonoidalPi._proof_10 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : I → Type u_5}
[inst_2 : (i : I) → CategoryTheory.Category.{u_4, u_5} (D i)]
[inst_3 : (i : I) → CategoryTheory.MonoidalCategory (D i)] (F : (i : I) → Cate... | false |
EuclideanGeometry.Sphere.IsDiameter.midpoint_eq_center | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
s.IsDiameter p₁ p₂ → midpoint ℝ p₁ p₂ = s.center | true |
Dilation.ratio_comp' | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
[inst_2 : PseudoEMetricSpace γ] {g : β →ᵈ γ} {f : α →ᵈ β},
(∃ x y, edist x y ≠ 0 ∧ edist x y ≠ ⊤) → Dilation.ratio (g.comp f) = Dilation.ratio g * Dilation.ratio f | true |
Nat.count_le_cardinal | Mathlib.SetTheory.Cardinal.NatCount | ∀ {p : ℕ → Prop} [inst : DecidablePred p] (n : ℕ), ↑(Nat.count p n) ≤ Cardinal.mk ↑{k | p k} | true |
Aesop.GoalUnsafe.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.GoalUnsafe} → t = t' → Aesop.GoalUnsafe.noConfusionType P t t' | false |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.initFn.match_1._@.Mathlib.Tactic.CategoryTheory.Elementwise.3754623819._hygCtx._hyg.2 | Mathlib.Tactic.CategoryTheory.Elementwise | (motive : Option (Lean.Level × Lean.Level) → Sort u_1) →
(level? : Option (Lean.Level × Lean.Level)) →
((levelW levelUF : Lean.Level) → motive (some (levelW, levelUF))) →
((x : Option (Lean.Level × Lean.Level)) → motive x) → motive level? | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.DefEqM.Context._sizeOf_1 | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.DefEqM.Context✝ → ℕ | false |
_private.Mathlib.AlgebraicGeometry.Cover.Open.0.AlgebraicGeometry.Scheme.OpenCover.ext_elem._simp_1_2 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
Std.DHashMap.Internal.Raw₀.contains_diff_eq_false_of_contains_eq_false_left | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α}, m₁.contains k = false → (m₁.diff m₂).contains k = false | true |
SpecialLinearGroup.instGroup._proof_10 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
(a : SpecialLinearGroup R V), a⁻¹ * a = 1 | false |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.rightHomologyData._proof_7 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H ... | false |
Std.Do.PostShape.pure.sizeOf_spec | Std.Do.PostCond | sizeOf Std.Do.PostShape.pure = 1 | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.preimage_mul_const_Icc_of_neg._simp_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Icc a b = Set.Ici a ∩ Set.Iic b | false |
_private.Mathlib.Analysis.InnerProductSpace.Semisimple.0.LinearMap.IsSymmetric.isFinitelySemisimple._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Semisimple | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.natDegree_preΨ'_pos._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {a b : ℕ}, (0 < a / b) = (0 < b ∧ b ≤ a) | false |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkEqTrans?.match_1 | Lean.Meta.AppBuilder | (motive : Option Lean.Expr → Option Lean.Expr → Sort u_1) →
(h₁? h₂? : Option Lean.Expr) →
(Unit → motive none none) →
((h : Lean.Expr) → motive none (some h)) →
((h : Lean.Expr) → motive (some h) none) → ((h₁ h₂ : Lean.Expr) → motive (some h₁) (some h₂)) → motive h₁? h₂? | false |
Std.ExtTreeMap.getD_ofList_of_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v fallback : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l → (Std.ExtTreeMap.ofList l cmp).getD k' fallback = v | true |
_private.Mathlib.Dynamics.OmegaLimit.0.mem_omegaLimit_iff_frequently₂._simp_1_2 | Mathlib.Dynamics.OmegaLimit | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β}, (f '' s ∩ t).Nonempty = (s ∩ f ⁻¹' t).Nonempty | false |
ENat.toENNReal_ne_top._simp_1 | Mathlib.Data.Real.ENatENNReal | ∀ {n : ℕ∞}, (↑n ≠ ⊤) = (n ≠ ⊤) | false |
Matroid.loopless_iff | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} (M : Matroid α), M.Loopless ↔ M.loops = ∅ | true |
FirstOrder.Language.BoundedFormula.sumElim_comp_relabelAux | Mathlib.ModelTheory.Syntax | ∀ {M : Type w} {α : Type u'} {β : Type v'} {n m : ℕ} {g : α → β ⊕ Fin n} {v : β → M} {xs : Fin (n + m) → M},
Sum.elim v xs ∘ FirstOrder.Language.BoundedFormula.relabelAux g m =
Sum.elim (Sum.elim v (xs ∘ Fin.castAdd m) ∘ g) (xs ∘ Fin.natAdd n) | true |
_private.Init.System.FilePath.0.System.instHashableFilePath.hash.match_1 | Init.System.FilePath | (motive : System.FilePath → Sort u_1) → (x : System.FilePath) → ((a : String) → motive { toString := a }) → motive x | false |
Finset.inf'._proof_1 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] (s : Finset β),
s.Nonempty → ∀ (f : β → α), s.inf (WithTop.some ∘ f) ≠ ⊤ | false |
Filter.div_mem_div | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {f g : Filter α} {s t : Set α}, s ∈ f → t ∈ g → s / t ∈ f / g | true |
Lean.FuzzyMatching.CharType.separator.elim | Lean.Data.FuzzyMatching | {motive : Lean.FuzzyMatching.CharType → Sort u} →
(t : Lean.FuzzyMatching.CharType) → t.ctorIdx = 2 → motive Lean.FuzzyMatching.CharType.separator → motive t | false |
MeasureTheory.pdf.eq_of_map_eq_withDensity' | Mathlib.Probability.Density | ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {m : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω}
{μ : MeasureTheory.Measure E} [MeasureTheory.SigmaFinite μ] {X : Ω → E} [MeasureTheory.HasPDF X ℙ μ]
(f : E → ENNReal),
AEMeasurable f μ → (MeasureTheory.Measure.map X ℙ = μ.withDensity f ↔ MeasureTheo... | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Option.getD.match_1.splitter | Mathlib.Computability.TuringMachine.ToPartrec | {α : Type u_1} →
(motive : Option α → Sort u_2) → (opt : Option α) → ((x : α) → motive (some x)) → (Unit → motive none) → motive opt | true |
mabs_div_lt_of_one_le_of_lt | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b n : G},
1 ≤ a → a < n → 1 ≤ b → b < n → |a / b|ₘ < n | true |
lebesgue_number_of_compact_open | Mathlib.Topology.UniformSpace.Compact | ∀ {α : Type ua} [inst : UniformSpace α] {K U : Set α},
IsCompact K → IsOpen U → K ⊆ U → ∃ V ∈ uniformity α, IsOpen V ∧ ∀ x ∈ K, UniformSpace.ball x V ⊆ U | true |
Array.mergeDedupWith.go._unary._proof_2 | Batteries.Data.Array.Merge | ∀ {α : Type u_1} (xs ys acc : Array α) (i j : ℕ),
¬i ≥ xs.size →
∀ (hj : ¬j ≥ ys.size),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun acc i => PSigma.casesOn i fun i j => xs.size + ys.size - (i + j))
⟨acc.push ys[j], ⟨i, j + 1⟩⟩ ⟨acc, ⟨i, j⟩⟩ | false |
Submodule.smul_le_smul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
{s t : SetSemiring A} {M N : Submodule R A}, SetSemiring.down s ⊆ SetSemiring.down t → M ≤ N → s • M ≤ t • N | true |
MeasureTheory.measureReal_abs_dual_gt_le_integral_charFunDual | Mathlib.MeasureTheory.Measure.IntegralCharFun | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {mE : MeasurableSpace E}
[OpensMeasurableSpace E] {μ : MeasureTheory.Measure E} [MeasureTheory.IsProbabilityMeasure μ] (L : StrongDual ℝ E)
{r : ℝ},
0 < r → μ.real {x | r < |L x|} ≤ 2⁻¹ * r * ‖∫ (t : ℝ) in -2 * r⁻¹..2 * r⁻¹, 1 - MeasureTheo... | true |
finRotate_last | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {n : ℕ}, (finRotate (n + 1)) (Fin.last n) = 0 | true |
Finset.instAddTorsorForall | Mathlib.LinearAlgebra.AffineSpace.Combination | {k : Type u_1} → [inst : Ring k] → {ι : Type u_4} → AddTorsor (ι → k) (ι → k) | true |
Std.Sat.AIG.RefVec.IfInput.rec | Std.Sat.AIG.If | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{motive : Std.Sat.AIG.RefVec.IfInput aig w → Sort u} →
((discr : aig.Ref) → (lhs rhs : aig.RefVec w) → motive { discr := discr, lhs := lhs, rhs := rhs }) →
(t : Std.Sat... | false |
InnerProductSpace.canonicalCovariantTensor.congr_simp | Mathlib.Analysis.Distribution.DerivNotation | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E],
InnerProductSpace.canonicalCovariantTensor E = InnerProductSpace.canonicalCovariantTensor E | true |
BitVec.not_lt_zero._simp_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, (x < 0#w) = False | false |
imp_false | Init.Core | ∀ {a : Prop}, a → False ↔ ¬a | true |
CategoryTheory.categoryFree._proof_5 | Mathlib.Algebra.Category.ModuleCat.Adjunctions | ∀ (R : Type u_1) [inst : CommRing R] (C : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
{W X Y Z : CategoryTheory.Free R C} (f : (W ⟶ X) →₀ R) (g : (X ⟶ Y) →₀ R) (h : (Y ⟶ Z) →₀ R),
((f.sum fun f' s => g.sum fun g' t => fun₀ | CategoryTheory.CategoryStruct.comp f' g' => s * t).sum fun f' s =>
h.su... | false |
_private.Mathlib.Data.Set.Prod.0.Set.compl_prod_eq_union._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β), (s ×ˢ t)ᶜ = sᶜ ×ˢ Set.univ ∪ Set.univ ×ˢ tᶜ | false |
upperPolar_empty | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop), upperPolar r ∅ = Set.univ | true |
AlgebraicGeometry.Scheme.Modules.conjugateEquiv_pullbackId_hom | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ (X : AlgebraicGeometry.Scheme),
(CategoryTheory.conjugateEquiv CategoryTheory.Adjunction.id
(AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction (CategoryTheory.CategoryStruct.id X)))
(AlgebraicGeometry.Scheme.Modules.pullbackId X).hom =
(AlgebraicGeometry.Scheme.Modules.pushforwardId X... | true |
HomologicalComplex₂.toGradedObjectMap | Mathlib.Algebra.Homology.HomologicalBicomplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
{K L : HomologicalComplex₂ C c₁ c₂} → (K ⟶ L) → (K.toGraded... | true |
Lean.Meta.useEtaStruct | Lean.Meta.Basic | Lean.Name → Lean.MetaM Bool | true |
CategoryTheory.Endofunctor.Algebra.functorOfNatTransId_inv_app_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
(X : CategoryTheory.Endofunctor.Algebra F),
(CategoryTheory.Endofunctor.Algebra.functorOfNatTransId.inv.app X).f = CategoryTheory.CategoryStruct.id X.a | true |
SkewMonoidAlgebra.coeff_single | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (a : G) (b : k) [inst_1 : DecidableEq G],
(SkewMonoidAlgebra.single a b).coeff = Pi.single a b | true |
Filter.Germ.total | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : LE β] [Std.Total fun x1 x2 => x1 ≤ x2],
Std.Total fun x1 x2 => x1 ≤ x2 | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect.0.Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.run.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | {α : Type} →
(motive : α × Lean.Elab.Tactic.BVDecide.Frontend.LemmaState → Sort u_1) →
(__discr : α × Lean.Elab.Tactic.BVDecide.Frontend.LemmaState) →
((res : α) → (state : Lean.Elab.Tactic.BVDecide.Frontend.LemmaState) → motive (res, state)) → motive __discr | false |
EReal.sub_add_cancel_right | Mathlib.Data.EReal.Operations | ∀ {a : EReal} {b : ℝ}, ↑b - (a + ↑b) = -a | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.