name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.SequentialProduct.functorMap_commSq_succ._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | ∀ (n : ℕ), n < n + 1 | false |
HasDerivWithinAt.clog | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | ∀ {f : ℂ → ℂ} {f' x : ℂ} {s : Set ℂ},
HasDerivWithinAt f f' s x → f x ∈ Complex.slitPlane → HasDerivWithinAt (fun t => Complex.log (f t)) (f' / f x) s x | true |
LinearEquiv.symmEquiv_apply_symm_apply | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂) (... | true |
List.alternatingProd._sunfold | Mathlib.Algebra.BigOperators.Group.List.Defs | {G : Type u_4} → [One G] → [Mul G] → [Inv G] → List G → G | false |
QuotientAddGroup.induction_on | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {C : α ⧸ s → Prop} (x : α ⧸ s), (∀ (z : α), C ↑z) → C x | true |
ProbabilityTheory.Kernel.compProd_of_not_isSFiniteKernel_left | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel (α × β) γ),
¬ProbabilityTheory.IsSFiniteKernel κ → κ.compProd η = 0 | true |
_private.Mathlib.Topology.Bornology.Absorbs.0.absorbs_inter._simp_1_1 | Mathlib.Topology.Bornology.Absorbs | ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α]
{s t : Set α}, Absorbs G₀ s t = ∀ᶠ (c : G₀) in Bornology.cobounded G₀, Set.MapsTo (fun x => c⁻¹ • x) t s | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.sum_Ico_Ico_comm._proof_1_4 | Mathlib.Algebra.BigOperators.Intervals | ∀ (a b a_1 b_1 : ℕ), (a ≤ a_1 ∧ a_1 < b) ∧ a_1 ≤ b_1 ∧ b_1 < b → (a ≤ b_1 ∧ b_1 < b) ∧ a ≤ a_1 ∧ a_1 < b_1 + 1 | false |
_private.Lean.Meta.Tactic.Cbv.TheoremsLookup.0.Lean.Meta.Sym.Simp.Theorems.insertMany | Lean.Meta.Tactic.Cbv.TheoremsLookup | Lean.Meta.Sym.Simp.Theorems → Array Lean.Meta.Sym.Simp.Theorem → Lean.Meta.Sym.Simp.Theorems | true |
PFun.fixInduction'._proof_2 | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {f : α →. β ⊕ α} {b : β} (a' : α),
b ∈ f.fix a' → ∀ (b' : β), Sum.inl b' ∈ f a' → Sum.inl b ∈ f a' | false |
isOpen_interior._simp_1 | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen (interior s) = True | false |
Order.Ideal.instInfSet | Mathlib.Order.Ideal | {P : Type u_1} → [inst : SemilatticeSup P] → [OrderBot P] → InfSet (Order.Ideal P) | true |
String.Slice.Pattern.Model.ForwardSliceSearcher.matchesAt_iff_splits | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos : s.Pos},
pat.isEmpty = false → (String.Slice.Pattern.Model.MatchesAt pat pos ↔ ∃ t₁ t₂, pos.Splits t₁ (pat.copy ++ t₂)) | true |
Plausible.InjectiveFunction.shrink._proof_1 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type} (xs : List ((_ : α) × α)),
(List.map Sigma.fst xs).Perm (List.map Sigma.snd xs) →
(List.map Sigma.snd xs).Nodup → (List.map Sigma.fst xs).Perm (List.map Sigma.snd xs) ∧ (List.map Sigma.snd xs).Nodup | false |
Lean.Parser.Tactic.case' | Init.Tactics | Lean.ParserDescr | true |
CategoryTheory.Coverage.mk.noConfusion | Mathlib.CategoryTheory.Sites.Coverage | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{P : Sort u} →
{toPrecoverage : CategoryTheory.Precoverage C} →
{pullback :
∀ ⦃X Y : C⦄ (f : Y ⟶ X),
∀ S ∈ toPrecoverage.coverings X, ∃ T ∈ toPrecoverage.coverings Y, T.FactorsThruAlong S f} →
{toPre... | false |
CategoryTheory.instHasLiftingPropertySnd | Mathlib.CategoryTheory.LiftingProperties.Limits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Y Z W : C} {g : Z ⟶ W} {t : Y ⟶ W}
[inst_1 : CategoryTheory.Limits.HasPullback g t] {T₁ T₂ : C} (p : T₁ ⟶ T₂) [CategoryTheory.HasLiftingProperty p g],
CategoryTheory.HasLiftingProperty p (CategoryTheory.Limits.pullback.snd g t) | true |
Subsemiring.unop_eq_bot._simp_1 | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocSemiring R] {S : Subsemiring Rᵐᵒᵖ}, (S.unop = ⊥) = (S = ⊥) | false |
MeasureTheory.Measure.addHaarScalarFactor_smul_congr | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} {A : Type u_2} [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : DistribMulAction G A]
[inst_3 : MeasurableSpace A] [inst_4 : TopologicalSpace A] [inst_5 : BorelSpace A] [inst_6 : IsTopologicalAddGroup A]
[LocallyCompactSpace A] [inst_8 : ContinuousConstSMul G A] (μ : MeasureTheory.Measure A) {ν... | true |
Aesop.ForwardRuleMatches.noConfusionType | Aesop.Tree.Data.ForwardRuleMatches | Sort u → Aesop.ForwardRuleMatches → Aesop.ForwardRuleMatches → Sort u | false |
DFinsupp.instLocallyFiniteOrder | Mathlib.Data.DFinsupp.Interval | {ι : Type u_1} →
{α : ι → Type u_2} →
[DecidableEq ι] →
[(i : ι) → DecidableEq (α i)] →
[inst : (i : ι) → PartialOrder (α i)] →
[inst_1 : (i : ι) → Zero (α i)] → [(i : ι) → LocallyFiniteOrder (α i)] → LocallyFiniteOrder (Π₀ (i : ι), α i) | true |
NonemptyFinLinOrd.mk | Mathlib.Order.Category.NonemptyFinLinOrd | (toLinOrd : LinOrd) → [nonempty : Nonempty ↑toLinOrd] → [fintype : Fintype ↑toLinOrd] → NonemptyFinLinOrd | true |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup | Init.Data.Format.Basic | Type | true |
instMonoidWithConvMatrix._proof_4 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : Monoid α] (a : WithConv (Matrix m n α)), a * 1 = a | false |
Lean.Meta.DefEqCacheKind | Lean.Meta.ExprDefEq | Type | true |
Lean.Elab.Term.Quotation.MatchResult.noConfusion | Lean.Elab.Quotation | {P : Sort u} →
{t t' : Lean.Elab.Term.Quotation.MatchResult} → t = t' → Lean.Elab.Term.Quotation.MatchResult.noConfusionType P t t' | false |
Finset.instFintypeSubtypeMemSubgroupInvMulSubgroup._simp_2 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] (s t : Finset α), ↑s * ↑t = ↑(s * t) | false |
MulRingSeminormClass.toMonoidHomClass | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} {inst : NonAssocRing α} {inst_1 : Semiring β}
{inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : MulRingSeminormClass F α β], MonoidHomClass F α β | true |
_private.Lean.Elab.CheckTactic.0.Lean.Elab.CheckTactic.elabCheckTactic.match_8 | Lean.Elab.CheckTactic | (motive : List Lean.MVarId × Lean.Elab.Term.State → Sort u_1) →
(__discr : List Lean.MVarId × Lean.Elab.Term.State) →
((goals : List Lean.MVarId) → (snd : Lean.Elab.Term.State) → motive (goals, snd)) → motive __discr | false |
HomologicalComplex.Hom.isIso_of_components | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : C₁ ⟶ C₂) [∀ (n : ι), CategoryTheory.IsIso (f.f n)], CategoryTheory.IsIso f | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.Context.symPrios | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.NormalizePattern.Context✝ → Lean.Meta.Grind.SymbolPriorities | true |
exists_seq_strictAnti_strictMono_tendsto | Mathlib.Topology.Order.IsLUB | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[FirstCountableTopology α] {x y : α},
x < y →
∃ u v,
StrictAnti u ∧
StrictMono v ∧
(∀ (k : ℕ), u k ∈ Set.Ioo x y) ∧
(∀ (l : ℕ), v l ∈ Set.Ioo x y) ∧
(∀ (k ... | true |
Asymptotics.IsLittleO.forall_isBigOWith | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =o[l] g → ∀ ⦃c : ℝ⦄, 0 < c → Asymptotics.IsBigOWith c l f g | true |
MvPowerSeries.lexOrder_eq_top_iff_eq_zero._simp_1 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : LinearOrder σ] [inst_2 : WellFoundedGT σ]
(φ : MvPowerSeries σ R), (φ.lexOrder = ⊤) = (φ = 0) | false |
ContinuousMap.instNormedCommRing._proof_2 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : NormedCommRing R] (a b : C(α, R)), a * b = b * a | false |
SSet.Subcomplex.N.mk | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | {X : SSet} →
{A : X.Subcomplex} →
{n : ℕ} →
(x : X.obj (Opposite.op (SimplexCategory.mk n))) →
x ∈ X.nonDegenerate n → x ∉ A.obj (Opposite.op (SimplexCategory.mk n)) → A.N | true |
em | Mathlib.Logic.Basic | ∀ (p : Prop), p ∨ ¬p | true |
PolynomialLaw.instAddCommMonoid._proof_4 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (f : M →ₚₗ[R] N), ↑0 • f = 0 | false |
IntermediateField.LinearDisjoint.adjoin_rank_eq_rank_left_of_isAlgebraic | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A : IntermediateField F E}
{L : Type w} [inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E],
A.LinearDisjoint L →
Algebra.IsAlgebraic F ↥A ∨ Algebra.IsAlgebraic F L →
Module.... | true |
TwoSidedIdeal.opOrderIso_apply | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R), TwoSidedIdeal.opOrderIso I = I.op | true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.withDensity_apply_eq_zero'._simp_1_4 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
Mathlib.Meta.NormNum.proveJacobiSym | Mathlib.Tactic.NormNum.LegendreSymbol | (ea : Q(ℤ)) → (eb : Q(ℕ)) → (er : Q(ℤ)) × Q(jacobiSym «$ea» «$eb» = «$er») | true |
Std.ExtTreeSet.insertMany_nil | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp], t.insertMany [] = t | true |
Ideal.count_associates_eq | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {a a₀ x : R} {n : ℕ},
Prime x →
¬x ∣ a → a₀ = x ^ n * a → (Associates.mk (Ideal.span {x})).count (Associates.mk (Ideal.span {a₀})).factors = n | true |
CategoryTheory.Kleisli.Adjunction.adj._proof_4 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (T : CategoryTheory.Monad C) {X : C}
{Y Y' : CategoryTheory.Kleisli T} (f : (CategoryTheory.Kleisli.Adjunction.toKleisli T).obj X ⟶ Y) (g : Y ⟶ Y'),
{ toFun := fun f => f.of, invFun := fun f => { of := f }, left_inv := ⋯, right_inv := ⋯ }
(Categor... | false |
Std.DHashMap.mem_of_mem_filter | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{f : (a : α) → β a → Bool} {k : α}, k ∈ Std.DHashMap.filter f m → k ∈ m | true |
Std.DTreeMap.Raw.get?_alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k k' : α} {f : Option (β k) → Option (β k)},
(t.alter k f).get? k' = if h : cmp k k' = Ordering.eq then cast ⋯ (f (t.get? k)) else t.get? k' | true |
ULift.mulAction._proof_1 | Mathlib.Algebra.Module.ULift | ∀ {R : Type u_2} {M : Type u_3} [inst : Monoid R] [inst_1 : MulAction R M] (x x_1 : ULift.{u_1, u_2} R) (b : M),
(x.down * x_1.down) • b = x.down • x_1.down • b | false |
Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Internal.Impl.contains k m₂ = false →
Std.DTreeMap.Internal.Impl.Const.getD (m₁.diff m₂ ⋯) k fallback =
Std.DTreeM... | true |
AddSubgroup.mk_le_mk._simp_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {s t : AddSubmonoid G} (h_neg : ∀ {x : G}, x ∈ s.carrier → -x ∈ s.carrier)
(h_neg' : ∀ {x : G}, x ∈ t.carrier → -x ∈ t.carrier),
({ toAddSubmonoid := s, neg_mem' := h_neg } ≤ { toAddSubmonoid := t, neg_mem' := h_neg' }) = (s ≤ t) | false |
EReal.induction₂_symm | Mathlib.Data.EReal.Basic | ∀ {P : EReal → EReal → Prop},
(∀ {x y : EReal}, P x y → P y x) →
P ⊤ ⊤ →
(∀ (x : ℝ), 0 < x → P ⊤ ↑x) →
P ⊤ 0 →
(∀ x < 0, P ⊤ ↑x) →
P ⊤ ⊥ →
(∀ (x : ℝ), 0 < x → P ↑x ⊥) →
(∀ (x y : ℝ), P ↑x ↑y) → P 0 ⊥ → (∀ x < 0, P ↑x ⊥) → P ⊥ ⊥ → ∀ (x y : EReal), P... | true |
MDifferentiableOn.clm_bundle_apply₂ | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {F₃ : Type u_5} {M : Type u_6}
[inst : NontriviallyNormedField 𝕜] {E₁ : B → Type u_7} [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
[inst_5 : Topological... | true |
LightProfinite.instInhabited._proof_3 | Mathlib.Topology.Category.LightProfinite.Basic | SecondCountableTopology PEmpty.{u_1 + 1} | false |
List.erase_eq_eraseIdx | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] (l : List α) (a : α),
l.erase a =
match List.idxOf? a l with
| none => l
| some i => l.eraseIdx i | true |
Bool.or_eq_true_iff | Init.Data.Bool | ∀ {x y : Bool}, (x || y) = true ↔ x = true ∨ y = true | true |
ContinuousLinearEquiv.symm_comp_self | Mathlib.Topology.Algebra.Module.Equiv | ∀ {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 σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_6 : TopologicalSpace M₂] [inst_7 : Ad... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.getKeyD_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
LocallyConstant.instNonAssocSemiring._proof_5 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : NonAssocSemiring Y] (x : ℕ)
(x_1 : LocallyConstant X Y), ⇑(x • x_1) = ⇑(x • x_1) | false |
_private.Init.Data.Option.Lemmas.0.Option.none_lt._simp_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α] {a : α}, (none < some a) = True | false |
Interval.addCommMonoid._proof_4 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (a : Interval α),
0 + a = a | false |
cfc_inv | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [inst_9 : ContinuousFunctionalCalculus R A p]... | true |
Std.TreeMap.getKey?_ofList_of_contains_eq_false | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α}, (List.map Prod.fst l).contains k = false → (Std.TreeMap.ofList l cmp).getKey? k = none | true |
UInt8.toUSize_ofNat' | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, n < UInt8.size → (UInt8.ofNat n).toUSize = USize.ofNat n | true |
ZMod.dft_eq_fourier | Mathlib.Analysis.Fourier.ZMod | ∀ {N : ℕ} [inst : NeZero N] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℂ E] [CompleteSpace E]
(Φ : ZMod N → E) (k : ZMod N), ZMod.dft Φ k = Fourier.fourierIntegral ZMod.toCircle MeasureTheory.Measure.count Φ k | true |
ContextFreeGrammar.produces_reverse | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {g : ContextFreeGrammar T} {u v : List (Symbol T g.NT)},
g.reverse.Produces u.reverse v.reverse ↔ g.Produces u v | true |
_private.Init.Data.List.Lemmas.0.List.mem_map.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (head : α) (l : List α), motive (head :: l)) → motive x | false |
Sym2.card_toFinset | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} [inst : DecidableEq α] (z : Sym2 α), z.toFinset.card = if z.IsDiag then 1 else 2 | true |
AffineSpace.vadd_asymptoticNhds | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] (u v : V),
u +ᵥ AffineSpace.asymptoticNhds k P v = AffineSpace.asymptoticNhds k P v | true |
_private.Mathlib.RingTheory.Coprime.Basic.0.IsCoprime.isUnit_of_dvd.match_1_1 | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {x y : R} (motive : x ∣ y → Prop) (d : x ∣ y),
(∀ (k : R) (hk : y = x * k), motive ⋯) → motive d | false |
SubMulAction.instSetLike.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M],
SubMulAction.instSetLike = { coe := SubMulAction.carrier, coe_injective' := ⋯ } | true |
_private.Init.Data.List.MapIdx.0.List.length_mapIdx_go._proof_1_6 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (l : List α) (x : Array β), ¬l.length + (x.size + 1) = l.length + 1 + x.size → False | false |
subset_sInf_def | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_2} (s : Set α) [inst : Preorder α] [inst_1 : InfSet α] [inst_2 : Inhabited ↑s],
sInf = fun t =>
if ht : t.Nonempty ∧ BddBelow t ∧ sInf (Subtype.val '' t) ∈ s then ⟨sInf (Subtype.val '' t), ⋯⟩ else default | true |
Std.ExtTreeMap.maxKeyD_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α},
(t.insert k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' | true |
FreeAddMagma.below | Mathlib.Algebra.Free | {α : Type u} → {motive : FreeAddMagma α → Sort u_1} → FreeAddMagma α → Sort (max (u + 1) u_1) | false |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred.boolAtom | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred | Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.M (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred) | true |
Subsemiring.nonneg._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Order | ∀ (R : Type u_1) [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R], AddLeftMono R | false |
Array.popWhile._unsafe_rec | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Array α | false |
CategoryTheory.Sigma.natIso_inv | Mathlib.CategoryTheory.Sigma.Basic | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] {q₁ q₂ : CategoryTheory.Functor ((i : I) × C i) D}
(h : (i : I) → (CategoryTheory.Sigma.incl i).comp q₁ ≅ (CategoryTheory.Sigma.incl i).comp q₂),
(CategoryTheory.... | true |
CategoryTheory.MorphismProperty.isStableUnderTransfiniteCompositionOfShape_iff | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (J : Type w)
[inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J],
W.IsStableUnderTransfiniteCompositionOfShape J ↔ W.transfiniteCompositionsOfShape J ≤ W | true |
NonUnitalRingHom.snd_comp_prod | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_3} {T : Type u_5} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring T] (f : R →ₙ+* S) (g : R →ₙ+* T),
(NonUnitalRingHom.snd S T).comp (f.prod g) = g | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_492 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
MeasureTheory.isFiniteMeasure_toFiniteAux | Mathlib.MeasureTheory.Measure.WithDensityFinite | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ],
MeasureTheory.IsFiniteMeasure μ.toFiniteAux | true |
List.head_cons | Init.Data.List.Basic | ∀ {α : Type u} {a : α} {l : List α} {h : a :: l ≠ []}, (a :: l).head h = a | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurable_from_prod_countable_left'._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
Std.DHashMap.instForInSigmaOfMonad | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{m : Type w → Type w'} →
[Monad m] → [inst : BEq α] → [inst_1 : Hashable α] → ForIn m (Std.DHashMap α β) ((a : α) × β a) | true |
ThreeGPFree.of_image | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : CommMonoid β] {s A : Set α} {t : Set β} {f : α → β},
IsMulFreimanHom 2 s t f → Set.InjOn f s → A ⊆ s → ThreeGPFree (f '' A) → ThreeGPFree A | true |
Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput.aig | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{old : Std.Sat.AIG α} → Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput old → Std.Sat.AIG α | true |
_private.Lean.Parser.Module.0.Lean.Parser.parseCommand.match_1 | Lean.Parser.Module | (motive : Option Lean.Parser.Error → Sort u_1) →
(x : Option Lean.Parser.Error) →
(Unit → motive none) → ((errorMsg : Lean.Parser.Error) → motive (some errorMsg)) → motive x | false |
CoalgCat.concreteCategory._proof_1 | Mathlib.Algebra.Category.CoalgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {X Y : CoalgCat R} (f : ↑X.toModuleCat →ₗc[R] ↑Y.toModuleCat),
{ toCoalgHom' := f }.toCoalgHom' = f | false |
Submonoid.mem_map_iff_mem | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F},
Function.Injective ⇑f → ∀ {S : Submonoid M} {x : M}, f x ∈ Submonoid.map f S ↔ x ∈ S | true |
CategoryTheory.Limits.Sigma.reindex | Mathlib.CategoryTheory.Limits.Shapes.Products | {β : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{γ : Type w'} →
(ε : β ≃ γ) →
(f : γ → C) →
[inst_1 : CategoryTheory.Limits.HasCoproduct f] →
[inst_2 : CategoryTheory.Limits.HasCoproduct (f ∘ ⇑ε)] → ∐ f ∘ ⇑ε ≅ ∐ f | true |
Lean.Meta.Grind.InjectiveInfo.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{us : List Lean.Level} →
{α β h : Lean.Expr} →
{inv? : Option (Lean.Expr × Lean.Expr)} →
{us' : List Lean.Level} →
{α' β' h' : Lean.Expr} →
{inv?' : Option (Lean.Expr × Lean.Expr)} →
{ us := us, α := α, β := β, h := h, inv? := inv? } =
... | false |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_31 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} [inst : BEq ι] [inst_1 : LawfulBEq ι] (a : ι) (l : List ι) (n : ℕ) (hi : n + 1 < (a :: l).length)
(w : ι) (h_5 : (a == (a :: l)[n + 1]) = true) (h_8 : (((a :: l).erase (a :: l)[n + 1])[n] == w) = true),
(List.findIdxs (fun x => x == w) (a :: l))[0] < (a :: l).length | false |
Units.mulLECancellable_val | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ), MulLECancellable ↑u | true |
CategoryTheory.Subobject.map_mk | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A X Y : C} (i : A ⟶ X) [inst_1 : CategoryTheory.Mono i]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Mono f],
(CategoryTheory.Subobject.map f).obj (CategoryTheory.Subobject.mk i) =
CategoryTheory.Subobject.mk (CategoryTheory.CategoryStruct.comp i f) | true |
Std.Time.Duration.subHours | Std.Time.Duration | Std.Time.Duration → Std.Time.Hour.Offset → Std.Time.Duration | true |
Std.DHashMap.Internal.Raw₀.get!_alter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α] {k k' : α},
(↑m).WF →
∀ [inst_3 : Inhabited (β k')] {f : Option (β k) → Option (β k)},
(m.alter k f).get! k' = if heq : (k == k') = true then (Option.map (cast ⋯) (f (m.get? k))... | true |
Lean.Meta.MVarRenaming.noConfusionType | Lean.Meta.Match.MVarRenaming | Sort u → Lean.Meta.MVarRenaming → Lean.Meta.MVarRenaming → Sort u | false |
Absorbs.sInter | Mathlib.Topology.Bornology.Absorbs | ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α] {t : Set α}
{S : Set (Set α)}, S.Finite → (∀ s ∈ S, Absorbs G₀ s t) → Absorbs G₀ (⋂₀ S) t | true |
CategoryTheory.MonoOver.imageForgetAdj._proof_1 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} [inst_1 : CategoryTheory.Limits.HasImages C]
(f : CategoryTheory.Over X) (g : CategoryTheory.MonoOver X) (k : f ⟶ (CategoryTheory.MonoOver.forget X).obj g),
(fun k =>
CategoryTheory.Over.homMk
(CategoryTheory.CategoryStruct.com... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.