name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Internal.Order.Basic.0.Lean.Order.admissible_pprod_snd.match_1_1 | Init.Internal.Order.Basic | ∀ {α : Sort u_1} {β : Sort u_2} [inst : Lean.Order.CCPO α] [inst_1 : Lean.Order.CCPO β] (c : α ×' β → Prop) (y : β)
(motive : Lean.Order.PProd.chain.snd c y → Prop) (h : Lean.Order.PProd.chain.snd c y),
(∀ (x : α) (hxy : c ⟨x, y⟩), motive ⋯) → motive h | false |
_private.Init.Data.Vector.Basic.0.Vector.mapM._proof_2 | Init.Data.Vector.Basic | ∀ {n : ℕ}, ∀ k ≤ n, ¬k < n → ¬k = n → False | false |
toIcoMod_intCast_mul_add' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℤ), toIcoMod hp (↑m * p + a) b = ↑m * p + toIcoMod hp a b | true |
TensorProduct.AlgebraTensorModule.map._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {A : Type u_2} {P : Type u_4} {Q : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid P] [inst_4 : Module R P] [inst_5 : Module A P]
[inst_6 : IsScalarTower R A P] [inst_7 : AddCommMonoid Q] [inst_8 : Module R Q],
SMulCommClass R A (TensorProduc... | false |
addConGen._proof_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (r : M → M → Prop), Equivalence (AddConGen.Rel r) | false |
_private.Mathlib.Algebra.Ring.Periodic.0.Function.Antiperiodic.int_mul_eq_of_eq_zero.match_1_1 | Mathlib.Algebra.Ring.Periodic | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | false |
sub_add_sub_cancel | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] (a b c : G), a - b + (b - c) = a - c | true |
Lean.Compiler.LCNF.ExtractClosed.M | Lean.Compiler.LCNF.ExtractClosed | Type → Type | true |
CategoryTheory.EnrichedFunctor.obj | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
{D : Type u₂} → [inst_3 : CategoryTheory.EnrichedCategory V D] → CategoryTheory.EnrichedFunctor V C D → C → D | true |
iteratedDeriv_div_const | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝕜' : Type u_6} [inst_1 : NormedDivisionRing 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {n : ℕ} (f : 𝕜 → 𝕜') (c : 𝕜'),
iteratedDeriv n (fun x => f x / c) x = iteratedDeriv n f x / c | true |
_private.Mathlib.Data.List.Dedup.0.List.dedup_cons_of_mem'._simp_1_2 | Mathlib.Data.List.Dedup | ∀ {a : Prop}, (¬¬a) = a | false |
MvQPF.Comp.map' | Mathlib.Data.QPF.Multivariate.Constructions.Comp | {n m : ℕ} →
{G : Fin2 n → TypeVec.{u} m → Type u} →
{α β : TypeVec.{u} m} → α.Arrow β → [(i : Fin2 n) → MvFunctor (G i)] → TypeVec.Arrow (fun i => G i α) fun i => G i β | true |
Std.TreeMap.contains_insert_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
(t.insert k v).contains k = true | true |
_private.Mathlib.Data.List.Cycle.0.Cycle.chain_of_pairwise._proof_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {r : α → α → Prop} (a : α) (l : List α),
(∀ a_1 ∈ ↑(a :: l), ∀ b ∈ ↑(a :: l), r a_1 b) →
a ∈ ↑(a :: l) → (∀ {b : α}, b ∈ l → b ∈ ↑(a :: l)) → ∀ b ∈ l ++ [a], r a b | false |
EIO.catchExceptions | Init.System.IO | {ε α : Type} → EIO ε α → (ε → BaseIO α) → BaseIO α | true |
NNReal.toReal_ne._simp_1 | Mathlib.Data.NNReal.Basic | ∀ (a b : NNReal), (a ≠ b) = (↑a ≠ ↑b) | false |
ContinuousAffineMap.differentiableOn | Mathlib.Analysis.Calculus.FDeriv.Affine | ∀ {𝕜 : 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)
{s : Set E}, DifferentiableOn 𝕜 (⇑f) s | true |
_private.Lean.Syntax.0.Lean.Syntax.isQuot._sparseCasesOn_2 | Lean.Syntax | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
IsometricContinuousFunctionalCalculus.casesOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : MetricSpace R] →
[inst_3 : IsTopologicalSemiring R] →
[inst_4 : ContinuousStar R] →
[inst_5 : Ring A] →
[inst_6 : StarR... | false |
Lean.Parser.longestMatchFnAux | Lean.Parser.Basic | Option Lean.Syntax → ℕ → ℕ → String.Pos.Raw → ℕ → List (Lean.Parser.Parser × ℕ) → Lean.Parser.ParserFn | true |
_private.Mathlib.Algebra.Group.Submonoid.Saturation.0.Submonoid.mem_saturation_iff.match_1_1 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : CommMonoid M] {s : Submonoid M} {x : M} (motive : (∃ y, x * y ∈ s) → Prop)
(x_1 : ∃ y, x * y ∈ s), (∀ (y : M) (hxy : x * y ∈ s), motive ⋯) → motive x_1 | false |
CategoryTheory.Classifier.SubobjectRepresentableBy.isTerminalΩ₀ | Mathlib.CategoryTheory.Topos.Classifier | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
{Ω : C} →
(h : CategoryTheory.Classifier.SubobjectRepresentableBy Ω) →
CategoryTheory.Limits.IsTerminal (CategoryTheory.Subobject.underlying.obj h.Ω₀) | true |
Aesop.Goal.lastExpandedInIteration | Aesop.Tree.Data | Aesop.Goal → Aesop.Iteration | true |
Equiv.Perm.disjoint_of_disjoint_support | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α] {H K : Subgroup (Equiv.Perm α)},
(∀ a ∈ H, ∀ b ∈ K, Disjoint a.support b.support) → Disjoint H K | true |
Setoid.completeLattice._proof_4 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} (x x_1 x_2 : Setoid α), x ≤ x_1 → x ≤ x_2 → ∀ (x_3 x_4 : α), x x_3 x_4 → x_1 x_3 x_4 ∧ x_2 x_3 x_4 | false |
List.orderedInsert._unsafe_rec | Mathlib.Data.List.Sort | {α : Type u_1} → (r : α → α → Prop) → [DecidableRel r] → α → List α → List α | false |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Presieve.uncurry_bind._simp_1_2 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
AffineAddMonoid.dim | Mathlib.Algebra.AffineMonoid.Embedding | (M : Type u_1) → [AddCancelCommMonoid M] → ℕ | true |
Filter.HasBasis.comap | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α} (f : β → α),
l.HasBasis p s → (Filter.comap f l).HasBasis p fun i => f ⁻¹' s i | true |
PresheafOfModules.hasColimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat)
[CategoryTheory.Limits.HasColimitsOfSize.{v₂, u₂, v, v + 1} AddCommGrpCat],
CategoryTheory.Limits.HasColimitsOfSize.{v₂, u₂, max u₁ v, max (max (max (v + 1) u) u₁) v₁} (PresheafOfModules R) | true |
_private.Mathlib.Data.Stream.Init.0.Stream'.mem_append_stream_right.match_1_1 | Mathlib.Data.Stream.Init | ∀ {α : Type u_1} (motive : (x : α) → List α → (x_2 : Stream' α) → x ∈ x_2 → Prop) (x : α) (x_1 : List α)
(x_2 : Stream' α) (x_3 : x ∈ x_2),
(∀ (x : α) (x_4 : Stream' α) (h : x ∈ x_4), motive x [] x_4 h) →
(∀ (a head : α) (l : List α) (s : Stream' α) (h : a ∈ s), motive a (head :: l) s h) → motive x x_1 x_2 x_3 | false |
AddMonoidHom.mkRingHomOfMulSelfOfTwoNeZero._proof_4 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : CommRing α] [inst_1 : CommRing β] (f : β →+ α) (x y : β),
(↑f).toFun (x + y) = (↑f).toFun x + (↑f).toFun y | false |
instUniqueSumsFinsupp | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_1} {G : Type u_2} [inst : AddZeroClass G] [UniqueSums G], UniqueSums (ι →₀ G) | true |
Std.ExtTreeSet.contains_iff_mem | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
t.contains k = true ↔ k ∈ t | true |
Std.TreeSet.getD_inter_of_not_mem_right | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
k ∉ t₂ → (t₁ ∩ t₂).getD k fallback = fallback | true |
CommRingCat.Colimits.Prequotient.add.elim | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J CommRingCat} →
{motive : CommRingCat.Colimits.Prequotient F → Sort u} →
(t : CommRingCat.Colimits.Prequotient F) →
t.ctorIdx = 4 → ((a a_1 : CommRingCat.Colimits.Prequotient F) → motive (a.add a_1)) → mo... | false |
_private.Lean.DocString.Add.0.Lean.addDocString'.match_1 | Lean.DocString.Add | (motive : Option (Lean.TSyntax `Lean.Parser.Command.docComment) → Sort u_1) →
(docString? : Option (Lean.TSyntax `Lean.Parser.Command.docComment)) →
((docString : Lean.TSyntax `Lean.Parser.Command.docComment) → motive (some docString)) →
(Unit → motive none) → motive docString? | false |
Int32.and_assoc | Init.Data.SInt.Bitwise | ∀ (a b c : Int32), a &&& b &&& c = a &&& (b &&& c) | true |
Nat.card_units | Mathlib.Data.Fintype.Units | ∀ (α : Type u_1) [inst : GroupWithZero α], Nat.card αˣ = Nat.card α - 1 | true |
Set.wellFoundedOn_empty | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} (r : α → α → Prop), ∅.WellFoundedOn r | true |
IsAdjoinRoot.adjoinRootAlgEquiv._proof_1 | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S],
RingHomClass (Polynomial R →ₐ[R] S) (Polynomial R) S | false |
Std.Sat.AIG.RefVec.get_cast | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig1 aig2 : Std.Sat.AIG α} (s : aig1.RefVec len)
(idx : ℕ) (hidx : idx < len) (hcast : aig1.decls.size ≤ aig2.decls.size),
(s.cast hcast).get idx hidx = (s.get idx hidx).cast hcast | true |
Lean.getProjFnInfoForField? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option (Lean.Name × Lean.ProjectionFunctionInfo) | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int8.instUpwardEnumerable._proof_3 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : Int8), i.toInt + ↑n ≤ Int8.maxValueSealed✝.toInt → i.toInt + ↑n ≤ Int8.maxValue.toInt | false |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Real.φ | Mathlib.Analysis.Normed.Algebra.GelfandMazur | {F : Type u_1} → [inst : NormedRing F] → [NormedAlgebra ℝ F] → F → ℝ × ℝ → F | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Cases.0.Lean.Elab.Tactic.Do.ProofMode.mCasesCore._sparseCasesOn_6 | Lean.Elab.Tactic.Do.ProofMode.Cases | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
ContinuousLinearMap.norm_smulRightL_le | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_1} {E : Type u_4} {Fₗ : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup Fₗ]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜 Fₗ],
‖ContinuousLinearMap.smulRightL 𝕜 E Fₗ‖ ≤ 1 | true |
Lean.Meta.Simp.getSimprocFromDeclImpl | Lean.Meta.Tactic.Simp.Simproc | Lean.Name → Lean.ImportM (Lean.Meta.Simp.Simproc ⊕ Lean.Meta.Simp.DSimproc) | true |
Finset.prod_insert' | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} {a : ι} [inst : CommMonoid M] [inst_1 : DecidableEq ι],
a ∉ s → (insert a s).prod = fun f => f a * ∏ x ∈ s, f x | true |
ProofWidgets.InteractiveCodeProps.noConfusionType | ProofWidgets.Component.Basic | Sort u → ProofWidgets.InteractiveCodeProps → ProofWidgets.InteractiveCodeProps → Sort u | false |
CategoryTheory.rightDistributor_ext₂_right | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] {f : J → C} {X Y Z : C}
{g h :
X ⟶ Ca... | true |
Padic.AddValuation.map_zero | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], Padic.addValuationDef 0 = ⊤ | true |
Matrix.GeneralLinearGroup.congr_simp | Mathlib.Analysis.Complex.UpperHalfPlane.Manifold | ∀ (n : Type u) (R : Type v) {inst : DecidableEq n} [inst_1 : DecidableEq n] [inst_2 : Fintype n] [inst_3 : Semiring R],
GL n R = GL n R | true |
Lean.Lsp.ParameterInformationLabel.name.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {name name_1 : String},
Lean.Lsp.ParameterInformationLabel.name name = Lean.Lsp.ParameterInformationLabel.name name_1 → name = name_1 | true |
CompactExhaustion._sizeOf_inst | Mathlib.Topology.Compactness.SigmaCompact | (X : Type u_4) → {inst : TopologicalSpace X} → [SizeOf X] → SizeOf (CompactExhaustion X) | false |
DirichletCharacter.changeLevel._proof_1 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n m : ℕ} (hm : n ∣ m),
MulChar.ofUnitHom ((MulChar.toUnitHom 1).comp (ZMod.unitsMap hm)) = 1 | false |
Orientation.areaForm'._proof_12 | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E], ContinuousSMul ℝ (E →L[ℝ] ℝ) | false |
_private.Mathlib.Algebra.Group.Center.0.Set.center_prod._simp_1_2 | Mathlib.Algebra.Group.Center | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | false |
DFinsupp.lex_lt_of_lt | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
(r : ι → ι → Prop) [IsStrictOrder ι r] {x y : Π₀ (i : ι), α i}, x < y → Pi.Lex r (fun {i} x1 x2 => x1 < x2) ⇑x ⇑y | true |
_private.Lean.Elab.DocString.0.Lean.Doc.Ref.seen | Lean.Elab.DocString | {α : Sort u_1} → Lean.Doc.Ref✝ α → Bool | true |
LinearMap.toAddMonoidHom_proj | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {ι : Type x} [inst : Semiring R] {φ : ι → Type i} [inst_1 : (i : ι) → AddCommMonoid (φ i)]
[inst_2 : (i : ι) → Module R (φ i)] (i : ι), (LinearMap.proj i).toAddMonoidHom = Pi.evalAddMonoidHom φ i | true |
Std.TreeMap.instSliceableRoiSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax | false |
Std.HashMap.toArray_keysIter | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
m.keysIter.toArray = m.keysArray | true |
Finset.tendsto_Ico_neg_atTop_atTop | Mathlib.Order.Filter.AtTopBot.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : LocallyFiniteOrder α] [NoTopOrder α], Filter.Tendsto (fun a => Finset.Ico (-a) a) Filter.atTop Filter.atTop | true |
Lean.Meta.Grind.EMatchTheorem.numParams | Lean.Meta.Tactic.Grind.Extension | Lean.Meta.Grind.EMatchTheorem → ℕ | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceE_X₁ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (f₂₃ : j ⟶ l)
(h₂₃ : CategoryTheory.CategoryStruct.... | true |
Std.HashMap.Raw.getKey!_congr | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited α], m.WF → ∀ {k k' : α}, (k == k') = true → m.getKey! k = m.getKey! k' | true |
QuaternionGroup.ctorElimType | Mathlib.GroupTheory.SpecificGroups.Quaternion | {n : ℕ} → {motive : QuaternionGroup n → Sort u} → ℕ → Sort (max 1 u) | false |
_private.Mathlib.MeasureTheory.Measure.Tight.0.MeasureTheory.exists_measure_iUnion_gt_of_isCompact_closure._simp_1_15 | Mathlib.MeasureTheory.Measure.Tight | ∀ {α : Type u_2} [inst : Semifield α] [inst_1 : PartialOrder α] [PosMulReflectLT α] {a b : α} [IsStrictOrderedRing α],
0 < b → (0 < a / b) = (0 < a) | false |
FirstOrder.Language.Sentence.realize_cardGe._simp_1 | Mathlib.ModelTheory.Semantics | ∀ (L : FirstOrder.Language) {M : Type w} [inst : L.Structure M] (n : ℕ),
M ⊨ FirstOrder.Language.Sentence.cardGe L n = (↑n ≤ Cardinal.mk M) | false |
_private.Mathlib.Algebra.Order.Ring.Abs.0.geomSum.match_1.eq_2 | Mathlib.Algebra.Order.Ring.Abs | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | true |
Std.TreeSet.Raw.min?_eq_some_iff_get?_eq_self_and_forall | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {km : α}, t.min? = some km ↔ t.get? km = some km ∧ ∀ k ∈ t, (cmp km k).isLE = true | true |
SimpleGraph.isNClique_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) {n : ℕ} {s : Finset α}, G.IsNClique n s ↔ G.IsClique ↑s ∧ s.card = n | true |
BitVec.toFin_mul | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x y : BitVec n), (x * y).toFin = x.toFin * y.toFin | true |
CategoryTheory.Functor.CommShift.OfComp.iso | Mathlib.CategoryTheory.Shift.CommShift | {C : Type u_1} →
{D : Type u_2} →
{E : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D ... | true |
Graph.IsSubgraph.isNonloopAt_congr | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G H : Graph α β},
H ≤ G → e ∈ H.edgeSet → (H.IsNonloopAt e x ↔ G.IsNonloopAt e x) | true |
Std.PRange.UpwardEnumerable.succMany_succ | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {n : ℕ} {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {a : α},
Std.PRange.succMany (n + 1) a = Std.PRange.succ (Std.PRange.succMany n a) | true |
ENNReal.image_coe_Ioi | Mathlib.Data.ENNReal.Operations | ∀ (x : NNReal), ENNReal.ofNNReal '' Set.Ioi x = Set.Ioo ↑x ⊤ | true |
_private.Lean.Elab.BuiltinEvalCommand.0.Lean.Elab.Command.EvalAction.mk._flat_ctor | Lean.Elab.BuiltinEvalCommand | Lean.Elab.Command.CommandElabM Lean.MessageData → Option Lean.Expr → Lean.Elab.Command.EvalAction✝ | false |
_private.Lean.Compiler.LCNF.ToImpureType.0.Lean.Compiler.LCNF.nameToImpureType.fillCache.match_1 | Lean.Compiler.LCNF.ToImpureType | (motive : Option Bool → Sort u_1) → (x : Option Bool) → (Unit → motive none) → ((a : Bool) → motive (some a)) → motive x | false |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isMeta._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.ComputeKind → Sort u} →
(t : Lean.Elab.ComputeKind) → motive Lean.Elab.ComputeKind.meta → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.MethodsRefPointed | Lean.Meta.Tactic.Grind.Types | NonemptyType | true |
ClosedSubmodule.mk.noConfusion | Mathlib.Topology.Algebra.Module.ClosedSubmodule | {R : Type u_2} →
{M : Type u_3} →
{inst : Semiring R} →
{inst_1 : AddCommMonoid M} →
{inst_2 : TopologicalSpace M} →
{inst_3 : Module R M} →
{P : Sort u} →
{toSubmodule : Submodule R M} →
{isClosed' : IsClosed toSubmodule.carrier} →
... | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getEntry?.match_1.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} (motive : List ((a : α) × β a) → Sort u_3) (k : α) (v : β k)
(l : List ((a : α) × β a)) (h_1 : Unit → motive [])
(h_2 : (k : α) → (v : β k) → (l : List ((a : α) × β a)) → motive (⟨k, v⟩ :: l)),
(match ⟨k, v⟩ :: l with
| [] => h_1 ()
| ⟨k, v⟩ :: l => h_2 k v l) =
h_2... | true |
EuclideanGeometry.oangle_sub_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p p₁ p₂ p₃ : P},
p₁ ≠ p →
p₂ ≠ p →
p₃ ≠ p → EuclideanGeometry.oangle p₁ p p... | true |
Mathlib.Linter.linter.style.commandStart | Mathlib.Tactic.Linter.Whitespace | Lean.Option Bool | true |
_private.Lean.Util.Profiler.0.Lean.Firefox.collideThreads.getStrIdx.match_1 | Lean.Util.Profiler | (motive : Lean.Firefox.StackTable → Sort u_1) →
(stackTable : Lean.Firefox.StackTable) →
((frame category subcategory : Array ℕ) →
(«prefix» : Array (Option ℕ)) →
(length : ℕ) →
motive
{ frame := frame, category := category, subcategory := subcategory, «prefix» := «pref... | false |
aeSeq.eq_1 | Mathlib.MeasureTheory.Function.AEMeasurableSequence | ∀ {ι : Sort u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : ι → α → β}
{μ : MeasureTheory.Measure α} (hf : ∀ (i : ι), AEMeasurable (f i) μ) (p : α → (ι → β) → Prop) (i : ι) (x : α),
aeSeq hf p i x = if x ∈ aeSeqSet hf p then AEMeasurable.mk (f i) ⋯ x else ⋯.some | true |
TendstoLocallyUniformly.fun_sub | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3} {X : Type u_4}
[inst_3 : TopologicalSpace X] {F G : ι → X → α} {f g : X → α} {l : Filter ι},
TendstoLocallyUniformly F f l →
TendstoLocallyUniformly G g l → TendstoLocallyUniformly (fun i i_1 => F i i_1 - G i i_1... | true |
Fin.lor._proof_1 | Init.Data.Fin.Basic | ∀ {n : ℕ}, ∀ a < n, ∀ (b : ℕ), a.lor b % n < n | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_23 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (upper : ℕ) (h : (_ : upper < aig.decls.size) ×' Std.Sat.AIG.toCNF.State✝ aig),
⟨upper, h⟩.1 < aig.decls.size | false |
StarOrderedRing.mk | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_3} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R],
(∀ (x y : R), x ≤ y ↔ ∃ p ∈ AddSubmonoid.closure (Set.range fun s => star s * s), y = x + p) → StarOrderedRing R | true |
Real.cos_add_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.cos (x + Real.pi) = -Real.cos x | true |
IsBaseChange.linearMapRightBaseChangeEquiv._proof_3 | Mathlib.RingTheory.TensorProduct.IsBaseChangeHom | ∀ {R : Type u_5} [inst : CommSemiring R] {S : Type u_1} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (M : Type u_2)
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{P : Type u_4} [inst_7 : AddCommMonoid P] [inst_8 : Module R P] [inst_9 : Module S ... | false |
_private.Init.Grind.Ring.CommSemiringAdapter.0.Lean.Grind.CommRing.Expr.toPolyS.match_4.eq_9 | Init.Grind.Ring.CommSemiringAdapter | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (k : ℤ) (h_1 : (n : ℤ) → motive (Lean.Grind.CommRing.Expr.num n))
(h_2 : (x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x))
(h_3 : (a b : Lean.Grind.CommRing.Expr) → motive (a.add b))
(h_4 : (a b : Lean.Grind.CommRing.Expr) → motive (a.mul b))... | true |
String.Pos.Splits.cast | Init.Data.String.Lemmas.Splits | ∀ {s₁ s₂ : String} {p : s₁.Pos} {t₁ t₂ : String} (h : s₁ = s₂), p.Splits t₁ t₂ → (p.cast h).Splits t₁ t₂ | true |
CategoryTheory.NatTrans.unop_whiskerRight | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} {E : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} E]
{H : CategoryTheory.Functor Dᵒᵖ Eᵒᵖ} (α : F ⟶ G),
CategoryTheory.NatTrans.unop (CategoryTheo... | true |
intervalIntegral.derivWithin_integral_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
∀ {s t : Set ℝ} [intervalIntegral.FTCFilter b (nhdsWithin b s) (nhdsWithin b t)],
StronglyMeasurableAtFilter f (nhdsWithin b t) MeasureTheory.vol... | true |
TwoPointing.prop_fst | Mathlib.Data.TwoPointing | TwoPointing.prop.toProd.1 = False | true |
Std.DTreeMap.instCoeTypeForall_2 | Std.Data.DTreeMap.AdditionalOperations | {α : Type u} → Coe (Type v) (α → Type v) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.