name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.RingTheory.DiscreteValuationRing.Basic.0.IsDiscreteValuationRing.exists_irreducible._simp_1_1 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] (ϖ : R),
Irreducible ϖ = (IsLocalRing.maximalIdeal R = Ideal.span {ϖ}) | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.RCasesPatt.parse._unsafe_rec | Lean.Elab.Tactic.RCases | Lean.Syntax → Lean.MetaM Lean.Elab.Tactic.RCases.RCasesPatt | false |
_private.Mathlib.Data.Set.Lattice.Image.0.Set.sInter_prod._simp_1_1 | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
CategoryTheory.Bicategory.triangle_assoc_comp_left_inv_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c) {Z : a ⟶ c}
(h :
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id b)) g ⟶
Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.leftUnitor g).inv)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator f (CategoryTheory.CategoryStruct.id b) g).inv h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.rightUnitor f).inv g) h | true |
ContT.monadLift | Mathlib.Control.Monad.Cont | {r : Type u} → {m : Type u → Type v} → [Monad m] → {α : Type u} → m α → ContT r m α | true |
BitVec.reduceGT | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.Simproc | true |
Lean.Grind.AC.Seq.unionFuel_k | Init.Grind.AC | ℕ → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | true |
RingHom.PropertyIsLocal.respectsIso | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
RingHom.PropertyIsLocal P → RingHom.RespectsIso P | true |
heq_of_eq_cast | Mathlib.Logic.Basic | ∀ {α β : Sort u} {a : α} {b : β} (e : β = α), a = cast e b → a ≍ b | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers.0.CategoryTheory.Limits.parallelPair.match_3.splitter | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | (motive : (X Y : CategoryTheory.Limits.WalkingParallelPair) → (X ⟶ Y) → Sort u_1) →
(X Y : CategoryTheory.Limits.WalkingParallelPair) →
(h : X ⟶ Y) →
((x : CategoryTheory.Limits.WalkingParallelPair) →
motive x x (CategoryTheory.Limits.WalkingParallelPairHom.id x)) →
(Unit →
motive CategoryTheory.Limits.WalkingParallelPair.zero CategoryTheory.Limits.WalkingParallelPair.one
CategoryTheory.Limits.WalkingParallelPairHom.left) →
(Unit →
motive CategoryTheory.Limits.WalkingParallelPair.zero CategoryTheory.Limits.WalkingParallelPair.one
CategoryTheory.Limits.WalkingParallelPairHom.right) →
motive X Y h | true |
WeierstrassCurve.instSMulVariableChange._proof_2 | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | (2 + 1).AtLeastTwo | false |
Vector.mem_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {x y : α}, x ∈ xs.push y ↔ x ∈ xs ∨ x = y | true |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Eval.0.Polynomial.eval_one_cyclotomic_not_prime_pow._simp_1_7 | Mathlib.RingTheory.Polynomial.Cyclotomic.Eval | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | false |
Std.Time.Modifier.Qorq | Std.Time.Format.Basic | Std.Time.Number ⊕ Std.Time.Text → Std.Time.Modifier | true |
ContinuousMap.liftCover'._proof_2 | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} (A : Set (Set α)) (i : { x // x ∈ A }), ↑i ∈ A | false |
QuadraticMap.Isometry.mk.sizeOf_spec | Mathlib.LinearAlgebra.QuadraticForm.Isometry | ∀ {R : Type u_1} {M₁ : Type u_3} {M₂ : Type u_4} {N : Type u_7} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid N] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
[inst_6 : Module R N] {Q₁ : QuadraticMap R M₁ N} {Q₂ : QuadraticMap R M₂ N} [inst_7 : SizeOf R] [inst_8 : SizeOf M₁]
[inst_9 : SizeOf M₂] [inst_10 : SizeOf N] (toLinearMap : M₁ →ₗ[R] M₂)
(map_app' : ∀ (m : M₁), Q₂ (toLinearMap.toFun m) = Q₁ m),
sizeOf { toLinearMap := toLinearMap, map_app' := map_app' } = 1 + sizeOf toLinearMap | true |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Continuous.exists_forall_le_of_isBounded._simp_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
MeasureTheory.Measure.FiniteAtFilter.integrableAtFilter | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {E : Type u_5} {mα : MeasurableSpace α} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure α}
{f : α → E} {l : Filter α} [l.IsMeasurablyGenerated],
StronglyMeasurableAtFilter f l μ →
μ.FiniteAtFilter l →
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l (norm ∘ f) → MeasureTheory.IntegrableAtFilter f l μ | true |
Matrix.piAlgEquiv._proof_3 | Mathlib.Data.Matrix.Basic | ∀ {n : Type u_1} {ι : Type u_2} {β : ι → Type u_3} (R : Type u_4) [inst : CommSemiring R]
[inst_1 : (i : ι) → Semiring (β i)] [inst_2 : (i : ι) → Algebra R (β i)] [inst_3 : Fintype n] [inst_4 : DecidableEq n]
(x : R) (x_1 : Matrix n n ((i : ι) → β i)),
Matrix.piRingEquiv.toRingHom (x • x_1) = Matrix.piRingEquiv.toRingHom (x • x_1) | false |
CategoryTheory.Discrete.addMonoidal_tensorObj_as | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ (M : Type u) [inst : AddMonoid M] (X Y : CategoryTheory.Discrete M),
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).as = X.as + Y.as | true |
MulOpposite.instMulZeroClass._proof_1 | Mathlib.Algebra.GroupWithZero.Opposite | ∀ {α : Type u_1} [inst : MulZeroClass α] (x : αᵐᵒᵖ), 0 * x = 0 | false |
Rat.instEncodable.match_1 | Mathlib.Data.Rat.Encodable | (motive : ℚ → Sort u_1) →
(x : ℚ) →
((a : ℤ) →
(b : ℕ) → (c : b ≠ 0) → (d : a.natAbs.Coprime b) → motive { num := a, den := b, den_nz := c, reduced := d }) →
motive x | false |
Std.ExtDHashMap.get?_insertMany_list_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{l : List ((a : α) × β a)} {k : α}, (List.map Sigma.fst l).contains k = false → (m.insertMany l).get? k = m.get? k | true |
LocallyConstant.instMulAction | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
{R : Type u_5} → [inst_1 : Monoid R] → [MulAction R Y] → MulAction R (LocallyConstant X Y) | true |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.coeff_X_mul_largeSchroderSeriesSeries_sq._simp_1_6 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ {α : Type u_2} [inst : Preorder α] (x : α), (x < x) = False | false |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkCongrSimpCore?.mkProof | Lean.Meta.CongrTheorems | Lean.Expr → Array Lean.Meta.CongrArgKind → Lean.MetaM Lean.Expr | true |
ZMod.commRing._proof_16 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) (x : ZMod n),
Nat.casesOn (motive := fun x => ℕ → ZMod x → ZMod x) n Semiring.npow (fun n => Semiring.npow) 0 x = 1 | false |
CategoryTheory.Monoidal.instMonoidalTransportedInverseSymmEquivalenceTransported._proof_3 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] (e : C ≌ D),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.ε (CategoryTheory.Monoidal.equivalenceTransported e).symm.inverse)
(CategoryTheory.Functor.OplaxMonoidal.η (CategoryTheory.Monoidal.equivalenceTransported e).symm.inverse) =
CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Monoidal.Transported e)) | false |
Real.contDiffOn_arcosh | Mathlib.Analysis.SpecialFunctions.Arcosh | ∀ {n : WithTop ℕ∞}, ContDiffOn ℝ n Real.arcosh (Set.Ioi 1) | true |
HomotopicalAlgebra.CofibrantObject.exists_bifibrant_map | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
{X₁ X₂ : HomotopicalAlgebra.CofibrantObject C} (f : X₁ ⟶ X₂),
∃ g,
CategoryTheory.CategoryStruct.comp X₁.iBifibrantResolutionObj
(HomotopicalAlgebra.BifibrantObject.ιCofibrantObject.map g) =
CategoryTheory.CategoryStruct.comp f X₂.iBifibrantResolutionObj | true |
CategoryTheory.Sieve.forallYonedaIsSheaf_iff_colimit | Mathlib.CategoryTheory.Sites.SheafOfTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (S : CategoryTheory.Sieve X),
(∀ (W : C), CategoryTheory.Presieve.IsSheafFor (CategoryTheory.yoneda.obj W) S.arrows) ↔
Nonempty (CategoryTheory.Limits.IsColimit S.arrows.cocone) | true |
_private.Mathlib.Geometry.Euclidean.Triangle.0.EuclideanGeometry.dist_sq_add_dist_sq_eq_two_mul_dist_midpoint_sq_add_half_dist_sq._simp_1_1 | Mathlib.Geometry.Euclidean.Triangle | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
Lean.Meta.ExtractLetsConfig.underBinder._default | Init.MetaTypes | Bool | false |
Std.DTreeMap.Internal.Impl.toListModel_eq_append | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] (k : α → Ordering) [Std.Internal.IsStrictCut compare k]
{l : Std.DTreeMap.Internal.Impl α β},
l.Ordered →
l.toListModel =
List.filter (fun x => k x.fst == Ordering.gt) l.toListModel ++
(List.find? (fun x => k x.fst == Ordering.eq) l.toListModel).toList ++
List.filter (fun x => k x.fst == Ordering.lt) l.toListModel | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL.match_3.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size →
Sort u_3)
(x : Std.DTreeMap.Internal.Impl α β)
(hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).Balanced)
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size)
(h_1 :
(lls : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) →
(lrs : ℕ) →
(lrk : α) →
(lrv : β lrk) →
(lrl lrr : Std.DTreeMap.Internal.Impl α β) →
(hlb :
(Std.DTreeMap.Internal.Impl.inner ls lk lv
(Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr)).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv
(Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr)).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive (Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr) hlb hlr)
(h_2 :
(size : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) →
(hlb :
(Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1)
Std.DTreeMap.Internal.Impl.leaf).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1)
Std.DTreeMap.Internal.Impl.leaf).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive (Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1) Std.DTreeMap.Internal.Impl.leaf hlb hlr)
(h_3 :
(x : Std.DTreeMap.Internal.Impl α β) →
(hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive Std.DTreeMap.Internal.Impl.leaf x hlb hlr),
(match Std.DTreeMap.Internal.Impl.leaf, x, hlb, hlr with
| Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1, Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr, hlb,
hlr => h_1 lls k_1 v_1 l_1 r_1 lrs lrk lrv lrl lrr hlb hlr
| Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1, Std.DTreeMap.Internal.Impl.leaf, hlb, hlr =>
h_2 size k_1 v_1 l_1 r_1 hlb hlr
| Std.DTreeMap.Internal.Impl.leaf, x, hlb, hlr => h_3 x hlb hlr) =
h_3 x hlb hlr | true |
UniformEquiv.prodAssoc._proof_1 | Mathlib.Topology.UniformSpace.Equiv | ∀ (α : Type u_2) (β : Type u_1) (γ : Type u_3) [inst : UniformSpace α] [inst_1 : UniformSpace β]
[inst_2 : UniformSpace γ], UniformContinuous fun a => (((fun p => p.1) ∘ fun p => p.1) a, a.1.2, a.2) | false |
gcd_isUnit_iff_isRelPrime | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] {a b : α}, IsUnit (gcd a b) ↔ IsRelPrime a b | true |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.mem_jacobson_bot.match_1_3 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {x : R} (y : R) (motive : (∃ b, (x * y + 1) * b = 1) → Prop)
(x_1 : ∃ b, (x * y + 1) * b = 1), (∀ (b : R) (hb : (x * y + 1) * b = 1), motive ⋯) → motive x_1 | false |
Array.all_append | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {f : α → Bool} {xs ys : Array α}, (xs ++ ys).all f = (xs.all f && ys.all f) | true |
Partition.disjoint | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {s x y : α} [inst : CompleteLattice α] {P : Partition s}, x ∈ P → y ∈ P → x ≠ y → Disjoint x y | true |
normFromConst._proof_1 | Mathlib.Analysis.Normed.Unbundled.SeminormFromConst | ∀ {K : Type u_1} [inst : Field K] {k : K} {g : RingSeminorm K} (hg1 : g 1 ≤ 1) (hg_k : g k ≠ 0) (hg_pm : IsPowMul ⇑g),
(seminormFromConst hg1 hg_k hg_pm) k ≠ 0 | false |
_private.Mathlib.Analysis.Normed.Unbundled.SpectralNorm.0.spectralNorm_unique._proof_1_34 | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ {K : Type u_2} [inst : NontriviallyNormedField K] {L : Type u_1} [inst_1 : Field L] [inst_2 : Algebra K L] (x : L),
autoParam (∀ (q : ℚ≥0) (a : id ↥K⟮x⟯), DivisionRing.nnqsmul q a = ↑q * a) DivisionRing.nnqsmul_def._autoParam | false |
CategoryTheory.Functor.leftOp_faithful | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C Dᵒᵖ} [F.Faithful], F.leftOp.Faithful | true |
Std.Sat.AIG.empty._proof_2 | Std.Sat.AIG.Basic | ∀ {α : Type}, #[Std.Sat.AIG.Decl.false][0] = Std.Sat.AIG.Decl.false | false |
SupIrred.supPrime | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : DistribLattice α] {a : α}, SupIrred a → SupPrime a | true |
Set.not_nonempty_empty | Mathlib.Data.Set.Basic | ∀ {α : Type u}, ¬∅.Nonempty | true |
_private.Mathlib.Analysis.SpecificLimits.Fibonacci.0.tendsto_fib_succ_div_fib_atTop._simp_1_2 | Mathlib.Analysis.SpecificLimits.Fibonacci | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
Units.mulRight_symm | Mathlib.Algebra.Group.Units.Equiv | ∀ {M : Type u_3} [inst : Monoid M] (u : Mˣ), Equiv.symm u.mulRight = u⁻¹.mulRight | true |
AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap_fst_assoc | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(s : CategoryTheory.Limits.PullbackCone f g) (i j : 𝒰.I₀) {Z_1 : AlgebraicGeometry.Scheme}
(h : CategoryTheory.Limits.pullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.gluedLiftPullbackMap 𝒰 f g s i j)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g) (𝒰.f i))
(𝒰.f j))
h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst ((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ s.fst 𝒰).f i)
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ s.fst 𝒰).f j))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullbackSymmetry s.fst (𝒰.f i)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.map (𝒰.f i) s.fst (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g
(CategoryTheory.CategoryStruct.id (𝒰.X i)) s.snd f ⋯ ⋯)
h)) | true |
Std.PRange.UpwardEnumerable.Map.mk | Init.Data.Range.Polymorphic.Map | {α : Type u} →
{β : Type v} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.UpwardEnumerable β] →
(toFun : α → β) →
Function.Injective toFun →
(∀ (a : α), Std.PRange.succ? (toFun a) = Option.map toFun (Std.PRange.succ? a)) →
(∀ (n : ℕ) (a : α), Std.PRange.succMany? n (toFun a) = Option.map toFun (Std.PRange.succMany? n a)) →
Std.PRange.UpwardEnumerable.Map α β | true |
_aux_Mathlib_Order_Defs_LinearOrder___macroRules_tacticCompareOfLessAndEq_rfl_1 | Mathlib.Order.Defs.LinearOrder | Lean.Macro | false |
Lean.Elab.Do.instInhabitedContInfo | Lean.Elab.Do.Basic | Inhabited Lean.Elab.Do.ContInfo | true |
Lean.Elab.Tactic.Do.SplitInfo.ctorElimType | Lean.Elab.Tactic.Do.VCGen.Split | {motive : Lean.Elab.Tactic.Do.SplitInfo → Sort u} → ℕ → Sort (max 1 u) | false |
Std.DTreeMap.Internal.RocSliceData.recOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.RocSliceData α β → Sort u_1} →
(t : Std.DTreeMap.Internal.RocSliceData α β) →
((treeMap : Std.DTreeMap.Internal.Impl α β) →
(range : Std.Roc α) → motive { treeMap := treeMap, range := range }) →
motive t | false |
_private.Mathlib.Analysis.BoxIntegral.Basic.0.BoxIntegral.integrable_of_bounded_and_ae_continuousWithinAt._simp_1_1 | Mathlib.Analysis.BoxIntegral.Basic | ∀ {E : Type u} {F : Type v} [inst : PseudoEMetricSpace F] [inst_1 : TopologicalSpace E] (f : E → F) {D : Set E} {x : E},
x ∈ D → (oscillationWithin f D x = 0) = ContinuousWithinAt f D x | false |
HomogeneousLocalization.homogeneousLocalizationCommRing._proof_1 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] {𝒜 : ι → σ} {x : Submonoid A} (y : HomogeneousLocalization 𝒜 x), (-y).val = -y.val | false |
_private.Std.Data.DTreeMap.Internal.Balanced.0.Std.DTreeMap.Internal.Impl.balancedAtRoot_zero_iff._proof_1_1 | Std.Data.DTreeMap.Internal.Balanced | ∀ {n : ℕ}, ¬(0 + n ≤ 1 ∨ 0 ≤ Std.DTreeMap.Internal.delta * n ∧ n ≤ Std.DTreeMap.Internal.delta * 0 ↔ n ≤ 1) → False | false |
EReal.bot_ne_zero | Mathlib.Data.EReal.Basic | ⊥ ≠ 0 | true |
LinearIndependent.notMem_span | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [Nontrivial R], LinearIndependent R v → ∀ (i : ι), v i ∉ Submodule.span R (v '' {i}ᶜ) | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.IsReduced.nodup_rightInvSeq._simp_1_5 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | false |
Equiv.algebra._proof_4 | Mathlib.Algebra.Algebra.TransferInstance | ∀ (R : Type u_2) {α : Type u_1} {β : Type u_3} [inst : CommSemiring R] (e : α ≃ β) [inst_1 : Semiring β]
[inst_2 : Algebra R β] (r : R) (x : α),
r • x =
(let __spread.0 := (RingEquiv.symm e.ringEquiv).toRingHom.comp (algebraMap R β);
{ toFun := fun r => e.symm ((algebraMap R β) r), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ })
r *
x | false |
AlgebraicGeometry.Scheme.evaluation | Mathlib.AlgebraicGeometry.ResidueField | (X : AlgebraicGeometry.Scheme) → (U : X.Opens) → (x : ↥X) → x ∈ U → (X.presheaf.obj (Opposite.op U) ⟶ X.residueField x) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Basic.0.SimpleGraph.exists_isExtremal_iff_exists.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Extremal.Basic | ∀ {V : Type u_1} [inst : Fintype V] (p : SimpleGraph V → Prop) (motive : (∃ G x, G.IsExtremal p) → Prop)
(x : ∃ G x, G.IsExtremal p),
(∀ (w : SimpleGraph V) (w_1 : DecidableRel w.Adj) (h : w.IsExtremal p), motive ⋯) → motive x | false |
«termC(_,_)» | Mathlib.Topology.ContinuousMap.Defs | Lean.ParserDescr | true |
Lean.PrettyPrinter.Delaborator.OmissionReason.rec | Lean.PrettyPrinter.Delaborator.Basic | {motive : Lean.PrettyPrinter.Delaborator.OmissionReason → Sort u} →
motive Lean.PrettyPrinter.Delaborator.OmissionReason.deep →
motive Lean.PrettyPrinter.Delaborator.OmissionReason.proof →
motive Lean.PrettyPrinter.Delaborator.OmissionReason.maxSteps →
((s : String) → motive (Lean.PrettyPrinter.Delaborator.OmissionReason.string s)) →
(t : Lean.PrettyPrinter.Delaborator.OmissionReason) → motive t | false |
MeasureTheory.LocallyIntegrable.mono_measure | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ ν : MeasureTheory.Measure X},
MeasureTheory.LocallyIntegrable f μ → ν ≤ μ → MeasureTheory.LocallyIntegrable f ν | true |
Lean.Lsp.SemanticTokenModifier.documentation.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenModifier → Sort u} →
(t : Lean.Lsp.SemanticTokenModifier) → t.ctorIdx = 8 → motive Lean.Lsp.SemanticTokenModifier.documentation → motive t | false |
_private.Mathlib.Algebra.BigOperators.Finprod.0.mul_finprod_cond_ne._proof_1_1 | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] {f : α → M} (a x : α), f x ≠ 1 → (¬x = a ↔ ¬f x = 1 ∧ ¬x = a) | false |
RingHom.finitePresentation_ofLocalizationSpanTarget | Mathlib.RingTheory.RingHom.FinitePresentation | RingHom.OfLocalizationSpanTarget @RingHom.FinitePresentation | true |
Std.Do.SPred.entails.eq_1 | Std.Do.SPred.Laws | ∀ (P_2 Q_2 : Std.Do.SPred []), (P_2 ⊢ₛ Q_2) = (P_2.down → Q_2.down) | true |
CategoryTheory.Limits.Bicone.toBinaryBiconeFunctor._proof_8 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {X_1 Y_1 : CategoryTheory.Limits.Bicone (CategoryTheory.Limits.pairFunction X Y)} (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp f.hom
{ pt := Y_1.pt, fst := Y_1.π CategoryTheory.Limits.WalkingPair.left,
snd := Y_1.π CategoryTheory.Limits.WalkingPair.right, inl := Y_1.ι CategoryTheory.Limits.WalkingPair.left,
inr := Y_1.ι CategoryTheory.Limits.WalkingPair.right, inl_fst := ⋯, inl_snd := ⋯, inr_fst := ⋯,
inr_snd := ⋯ }.snd =
{ pt := X_1.pt, fst := X_1.π CategoryTheory.Limits.WalkingPair.left,
snd := X_1.π CategoryTheory.Limits.WalkingPair.right, inl := X_1.ι CategoryTheory.Limits.WalkingPair.left,
inr := X_1.ι CategoryTheory.Limits.WalkingPair.right, inl_fst := ⋯, inl_snd := ⋯, inr_fst := ⋯,
inr_snd := ⋯ }.snd | false |
_private.Lean.Elab.Deriving.Ord.0.deriving.ord.linear_construction_threshold | Lean.Elab.Deriving.Ord | Lean.Option ℕ | true |
Lean.Widget.RpcEncodablePacket._sizeOf_1._@.Lean.Widget.UserWidget.577854155._hygCtx._hyg.1 | Lean.Widget.UserWidget | Lean.Widget.RpcEncodablePacket✝ → ℕ | false |
_aux_Mathlib_Topology_Algebra_Module_Equiv___unexpand_ContinuousLinearEquiv_1 | Mathlib.Topology.Algebra.Module.Equiv | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.RingTheory.Localization.Integral.0.IsLocalization.integerNormalization_eval₂_eq_zero.match_1_1 | Mathlib.RingTheory.Localization.Integral | ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : IsLocalization M S] (p : Polynomial S)
(motive : (∃ b ∈ M, Polynomial.map (algebraMap R S) (IsLocalization.integerNormalization M p) = b • p) → Prop)
(x : ∃ b ∈ M, Polynomial.map (algebraMap R S) (IsLocalization.integerNormalization M p) = b • p),
(∀ (b : R) (hb₁ : b ∈ M) (hb₂ : Polynomial.map (algebraMap R S) (IsLocalization.integerNormalization M p) = b • p),
motive ⋯) →
motive x | false |
_private.Lean.Environment.0.Lean.Environment.ConstPromiseVal.mk.injEq | Lean.Environment | ∀ (privateConstInfo exportedConstInfo : Lean.ConstantInfo) (exts : Array Lean.EnvExtensionState)
(nestedConsts : Lean.VisibilityMap✝ Lean.AsyncConsts✝) (privateConstInfo_1 exportedConstInfo_1 : Lean.ConstantInfo)
(exts_1 : Array Lean.EnvExtensionState) (nestedConsts_1 : Lean.VisibilityMap✝¹ Lean.AsyncConsts✝¹),
({ privateConstInfo := privateConstInfo, exportedConstInfo := exportedConstInfo, exts := exts,
nestedConsts := nestedConsts } =
{ privateConstInfo := privateConstInfo_1, exportedConstInfo := exportedConstInfo_1, exts := exts_1,
nestedConsts := nestedConsts_1 }) =
(privateConstInfo = privateConstInfo_1 ∧
exportedConstInfo = exportedConstInfo_1 ∧ exts = exts_1 ∧ nestedConsts = nestedConsts_1) | true |
_private.Mathlib.Analysis.Convex.Between.0.sbtw_of_sbtw_of_sbtw_of_mem_affineSpan_pair._simp_1_3 | Mathlib.Analysis.Convex.Between | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α] [inst_2 : DecidableLT α] {a : α}, (SignType.sign a = 1) = (0 < a) | false |
DFinsupp.coeFnLinearMap_apply | Mathlib.Data.DFinsupp.Module | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : Semiring γ] [inst_1 : (i : ι) → AddCommMonoid (β i)]
[inst_2 : (i : ι) → Module γ (β i)] (v : Π₀ (i : ι), β i), (DFinsupp.coeFnLinearMap γ) v = ⇑v | true |
Bimod.instCategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{A B : CategoryTheory.Mon C} {X Y : Bimod A B} (f : X.Hom Y), Bimod.comp X.id' f = f | false |
AddConstMap.mk.injEq | Mathlib.Algebra.AddConstMap.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H} (toFun : G → H)
(map_add_const' : ∀ (x : G), toFun (x + a) = toFun x + b) (toFun_1 : G → H)
(map_add_const'_1 : ∀ (x : G), toFun_1 (x + a) = toFun_1 x + b),
({ toFun := toFun, map_add_const' := map_add_const' } = { toFun := toFun_1, map_add_const' := map_add_const'_1 }) =
(toFun = toFun_1) | true |
solvable_of_solvable_injective | Mathlib.GroupTheory.Solvable | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] {f : G →* G'},
Function.Injective ⇑f → ∀ [IsSolvable G'], IsSolvable G | true |
CategoryTheory.Limits.cokernelOrderHom_coe | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasCokernels C] (X : C) (a : CategoryTheory.Subobject X),
(CategoryTheory.Limits.cokernelOrderHom X) a =
CategoryTheory.Subobject.lift (fun x f x_1 => CategoryTheory.Subobject.mk (CategoryTheory.Limits.cokernel.π f).op) ⋯
a | true |
CategoryTheory.WithInitial.liftUnique | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
{Z : D} →
(F : CategoryTheory.Functor C D) →
(M : (x : C) → Z ⟶ F.obj x) →
(hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (M x) (F.map f) = M y) →
(G : CategoryTheory.Functor (CategoryTheory.WithInitial C) D) →
(h : CategoryTheory.WithInitial.incl.comp G ≅ F) →
(hG : G.obj CategoryTheory.WithInitial.star ≅ Z) →
(∀ (x : C),
CategoryTheory.CategoryStruct.comp hG.symm.hom
(G.map
(CategoryTheory.WithInitial.starInitial.to (CategoryTheory.WithInitial.incl.obj x))) =
CategoryTheory.CategoryStruct.comp (M x) (h.symm.hom.app x)) →
(G ≅ CategoryTheory.WithInitial.lift F M hM) | true |
Mathlib.Tactic.Translate.Reorder.rec_3 | Mathlib.Tactic.Translate.Reorder | {motive_1 : Mathlib.Tactic.Translate.Reorder → Sort u} →
{motive_2 : Array (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_3 : List (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_4 : ℕ × Mathlib.Tactic.Translate.Reorder → Sort u} →
((perm : List { l // 2 ≤ l.length }) →
(argReorders : Array (ℕ × Mathlib.Tactic.Translate.Reorder)) →
motive_2 argReorders → motive_1 { perm := perm, argReorders := argReorders }) →
((toList : List (ℕ × Mathlib.Tactic.Translate.Reorder)) → motive_3 toList → motive_2 { toList := toList }) →
motive_3 [] →
((head : ℕ × Mathlib.Tactic.Translate.Reorder) →
(tail : List (ℕ × Mathlib.Tactic.Translate.Reorder)) →
motive_4 head → motive_3 tail → motive_3 (head :: tail)) →
((fst : ℕ) → (snd : Mathlib.Tactic.Translate.Reorder) → motive_1 snd → motive_4 (fst, snd)) →
(t : ℕ × Mathlib.Tactic.Translate.Reorder) → motive_4 t | false |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.mkEMatchTheoremWithKind'? | Lean.Meta.Tactic.Grind.Internalize | Lean.Meta.Grind.Origin →
Array Lean.Name →
Lean.Expr →
Lean.Meta.Grind.EMatchTheoremKind →
Lean.Meta.Grind.SymbolPriorities → Lean.MetaM (Option Lean.Meta.Grind.EMatchTheorem) | true |
Stream'.WSeq.LiftRelO.eq_2 | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (C : Stream'.WSeq α → Stream'.WSeq β → Prop) (a : α) (s : Stream'.WSeq α)
(b : β) (t : Stream'.WSeq β), Stream'.WSeq.LiftRelO R C (some (a, s)) (some (b, t)) = (R a b ∧ C s t) | true |
SatisfiesM_Id_eq | Batteries.Classes.SatisfiesM | ∀ {type : Type u_1} {p : type → Prop} {x : Id type}, SatisfiesM p x ↔ p x | true |
CategoryTheory.Functor.PushoutObjObj.ι_iso_of_iso_right._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_5} {C₂ : Type u_6} {C₃ : Type u_2} [inst : CategoryTheory.Category.{u_3, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_4, u_6} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {f₁ : CategoryTheory.Arrow C₁}
{f₂ f₂' : CategoryTheory.Arrow C₂} (sq₁₂ : F.PushoutObjObj f₁.hom f₂.hom) (sq₁₂' : F.PushoutObjObj f₁.hom f₂'.hom)
(iso : f₂ ≅ f₂'),
CategoryTheory.CategoryStruct.comp (sq₁₂'.mapArrowRight sq₁₂ iso.inv) (sq₁₂.mapArrowRight sq₁₂' iso.hom) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Arrow.mk sq₁₂'.ι) | false |
nonunits | Mathlib.RingTheory.Ideal.Nonunits | (α : Type u_4) → [Monoid α] → Set α | true |
_private.Mathlib.Algebra.Group.Pointwise.Finset.Basic.0.Finset.card_le_card_sub_left.match_1_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} {s : Finset α} (motive : s.Nonempty → Prop) (hs : s.Nonempty),
(∀ (w : α) (ha : w ∈ s), motive ⋯) → motive hs | false |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Widget.InteractiveGoal.3114798910._hygCtx._hyg.1.recOn | Lean.Widget.InteractiveGoal | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
(t : Lean.Widget.RpcEncodablePacket✝) →
((hyps type ctx : Lean.Json) →
(userName? : Option Lean.Json) →
(goalPrefix mvarId : Lean.Json) →
(isInserted? isRemoved? : Option Lean.Json) →
motive
{ hyps := hyps, type := type, ctx := ctx, userName? := userName?, goalPrefix := goalPrefix,
mvarId := mvarId, isInserted? := isInserted?, isRemoved? := isRemoved? }) →
motive t | false |
_private.Mathlib.Data.Nat.Choose.Basic.0.Nat.choose_mul_add._proof_1_1 | Mathlib.Data.Nat.Choose.Basic | ∀ {m n : ℕ},
(m * (n - 1 + 1) + (n - 1 + 1)).choose (n - 1 + 1) * ((m * (n - 1 + 1)).factorial * (n - 1 + 1).factorial) =
(m * (n - 1 + 1) + (n - 1 + 1)).choose (n - 1 + 1) * (m * (n - 1 + 1)).factorial * (n - 1 + 1).factorial | false |
MonoidHom.noncommPiCoprodEquiv._proof_4 | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {M : Type u_2} [inst : Monoid M] {ι : Type u_1} {N : ι → Type u_3} [inst_1 : (i : ι) → Monoid (N i)]
[inst_2 : DecidableEq ι] (f : ((i : ι) → N i) →* M) (x x_1 : ι),
x ≠ x_1 → ∀ (x_2 : N x) (y : N x_1), Commute (f (Pi.mulSingle x x_2)) (f (Pi.mulSingle x_1 y)) | false |
_private.Mathlib.Data.Set.Sigma.0.Set.sigma_eq_empty_iff._simp_1_3 | Mathlib.Data.Set.Sigma | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
Std.Time.OffsetX.hourMinuteSecond | Std.Time.Format.Basic | Std.Time.OffsetX | true |
LinearIsometry.extend._proof_7 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {V : Type u_2} [inst_1 : NormedAddCommGroup V] [inst_2 : InnerProductSpace 𝕜 V]
[FiniteDimensional 𝕜 V] {S : Submodule 𝕜 V} (L : ↥S →ₗᵢ[𝕜] V), FiniteDimensional 𝕜 ↥L.rangeᗮ | false |
MeasureTheory.SMulInvariantMeasure.mk | Mathlib.MeasureTheory.Group.Defs | ∀ {M : Type u_1} {α : Type u_2} [inst : SMul M α] {x : MeasurableSpace α} {μ : MeasureTheory.Measure α},
(∀ (c : M) ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c • x) ⁻¹' s) = μ s) → MeasureTheory.SMulInvariantMeasure M α μ | true |
MvPFunctor.WPath.child.noConfusion | Mathlib.Data.PFunctor.Multivariate.W | {n : ℕ} →
{P : MvPFunctor.{u} (n + 1)} →
{P_1 : Sort u_1} →
{a : P.A} →
{f : P.last.B a → P.last.W} →
{i : Fin2 n} →
{j : P.last.B a} →
{c : P.WPath (f j) i} →
{a' : P.A} →
{f' : P.last.B a' → P.last.W} →
{i' : Fin2 n} →
{j' : P.last.B a'} →
{c' : P.WPath (f' j') i'} →
WType.mk a f = WType.mk a' f' →
i = i' →
MvPFunctor.WPath.child a f i j c ≍ MvPFunctor.WPath.child a' f' i' j' c' →
(a ≍ a' → f ≍ f' → i ≍ i' → j ≍ j' → c ≍ c' → P_1) → P_1 | false |
AbstractSimplicialComplex.ext | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ {ι : Type u_1} {x y : AbstractSimplicialComplex ι}, x.faces = y.faces → x = y | true |
Std.Tactic.BVDecide.BVExpr._impl.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : (a : ℕ) → Std.Tactic.BVDecide.BVExpr._impl a → Sort u} →
{a : ℕ} →
(t : Std.Tactic.BVDecide.BVExpr._impl a) →
((hashCode : UInt64) → {w : ℕ} → (idx : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var._impl hashCode idx)) →
((hashCode : UInt64) →
{w : ℕ} → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const._impl hashCode val)) →
((hashCode : UInt64) →
{w : ℕ} →
(start len : ℕ) →
(expr : Std.Tactic.BVDecide.BVExpr w) →
motive len (Std.Tactic.BVDecide.BVExpr.extract._impl hashCode start len expr)) →
((hashCode : UInt64) →
{w : ℕ} →
(lhs : Std.Tactic.BVDecide.BVExpr w) →
(op : Std.Tactic.BVDecide.BVBinOp) →
(rhs : Std.Tactic.BVDecide.BVExpr w) →
motive w (Std.Tactic.BVDecide.BVExpr.bin._impl hashCode lhs op rhs)) →
((hashCode : UInt64) →
{w : ℕ} →
(op : Std.Tactic.BVDecide.BVUnOp) →
(operand : Std.Tactic.BVDecide.BVExpr w) →
motive w (Std.Tactic.BVDecide.BVExpr.un._impl hashCode op operand)) →
((hashCode : UInt64) →
{l r w : ℕ} →
(lhs : Std.Tactic.BVDecide.BVExpr l) →
(rhs : Std.Tactic.BVDecide.BVExpr r) →
(h : w = l + r) → motive w (Std.Tactic.BVDecide.BVExpr.append._impl hashCode lhs rhs h)) →
((hashCode : UInt64) →
{w w' : ℕ} →
(n : ℕ) →
(expr : Std.Tactic.BVDecide.BVExpr w) →
(h : w' = w * n) →
motive w' (Std.Tactic.BVDecide.BVExpr.replicate._impl hashCode n expr h)) →
((hashCode : UInt64) →
{m n : ℕ} →
(lhs : Std.Tactic.BVDecide.BVExpr m) →
(rhs : Std.Tactic.BVDecide.BVExpr n) →
motive m (Std.Tactic.BVDecide.BVExpr.shiftLeft._impl hashCode lhs rhs)) →
((hashCode : UInt64) →
{m n : ℕ} →
(lhs : Std.Tactic.BVDecide.BVExpr m) →
(rhs : Std.Tactic.BVDecide.BVExpr n) →
motive m (Std.Tactic.BVDecide.BVExpr.shiftRight._impl hashCode lhs rhs)) →
((hashCode : UInt64) →
{m n : ℕ} →
(lhs : Std.Tactic.BVDecide.BVExpr m) →
(rhs : Std.Tactic.BVDecide.BVExpr n) →
motive m (Std.Tactic.BVDecide.BVExpr.arithShiftRight._impl hashCode lhs rhs)) →
motive a t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.