tasksource/leandojo huggingface dataset:
Theorem: collinear_empty
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [collinear_iff_rank_le_one, vectorSpan_empty]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.243973
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
⊢ Collinear k ∅

tactic: simp
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.243973
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
⊢ Module.rank k { x // x ∈ ⊥ } ≤ 1
Theorem: MeasureTheory.zero_trim
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [Measure.trim, @OuterMeasure.toMeasure_zero _ m]
state_before: α : Type u_1
β : Type ?u.3496586
γ : Type ?u.3496589
δ : Type ?u.3496592
ι : Type ?u.3496595
R : Type ?u.3496598
R' : Type ?u.3496601
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
hm : m ≤ m0
⊢ trim 0 hm = 0
Theorem: lt_mul_inv_iff_mul_lt
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [inv_mul_cancel_right]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ c * b < a * b⁻¹ * b ↔ c * b < a
Theorem: IsCentralScalar.unop_smul_eq_smul
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: induction m using MulOpposite.rec'
state_before: M✝ : Type ?u.6042
N : Type ?u.6045
G : Type ?u.6048
A : Type ?u.6051
B : Type ?u.6054
α✝ : Type ?u.6057
β : Type ?u.6060
γ : Type ?u.6063
δ : Type ?u.6066
M : Type u_1
α : Type u_2
inst✝² : SMul M α
inst✝¹ : SMul Mᵐᵒᵖ α
inst✝ : IsCentralScalar M α
m : Mᵐᵒᵖ
a : α
⊢ MulOpposite.unop m • a = m • a

tactic: exact (IsCentralScalar.op_smul_eq_smul _ a).symm
state_before: case h
M✝ : Type ?u.6042
N : Type ?u.6045
G : Type ?u.6048
A : Type ?u.6051
B : Type ?u.6054
α✝ : Type ?u.6057
β : Type ?u.6060
γ : Type ?u.6063
δ : Type ?u.6066
M : Type u_1
α : Type u_2
inst✝² : SMul M α
inst✝¹ : SMul Mᵐᵒᵖ α
inst✝ : IsCentralScalar M α
a : α
X✝ : M
⊢ MulOpposite.unop (MulOpposite.op X✝) • a = MulOpposite.op X✝ • a
Theorem: LucasLehmer.X.card_eq
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: dsimp [X]
state_before: q : ℕ+
⊢ Fintype.card (X q) = ↑q ^ 2

tactic: rw [Fintype.card_prod, ZMod.card q, sq]
state_before: q : ℕ+
⊢ Fintype.card (ZMod ↑q × ZMod ↑q) = ↑q ^ 2
Theorem: CategoryTheory.Limits.inr_pushoutLeftPushoutInrIso_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [Iso.comp_inv_eq, inr_pushoutLeftPushoutInrIso_hom]
state_before: C : Type u
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
g' : Z ⟶ W
inst✝² : HasPushout f g
inst✝¹ : HasPushout pushout.inr g'
inst✝ : HasPushout f (g ≫ g')
⊢ pushout.inr ≫ (pushoutLeftPushoutInrIso f g g').inv = pushout.inr
Theorem: Nat.div_eq_sub_div
File: Std/Data/Nat/Lemmas.lean

tactic: rw [div_eq a, if_pos]
state_before: b a : Nat
h₁ : 0 < b
h₂ : b ≤ a
⊢ a / b = (a - b) / b + 1

tactic: constructor <;> assumption
state_before: case hc
b a : Nat
h₁ : 0 < b
h₂ : b ≤ a
⊢ 0 < b ∧ b ≤ a
Theorem: affineHomeomorph_image_I
File: Mathlib/Topology/UnitInterval.lean

tactic: simp [h]
state_before: 𝕜 : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : TopologicalRing 𝕜
a b : 𝕜
h : 0 < a
⊢ ↑(affineHomeomorph a b (_ : a ≠ 0)) '' Icc 0 1 = Icc b (a + b)
Theorem: Real.sqrt_div_self
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [sqrt_div_self', one_div]
state_before: x : ℝ
⊢ sqrt x / x = (sqrt x)⁻¹
Theorem: MeasureTheory.snorm'_le_snormEssSup
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [measure_univ]
state_before: α : Type u_1
E : Type ?u.4185587
F : Type u_2
G : Type ?u.4185593
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
hq_pos : 0 < q
f : α → F
inst✝ : IsProbabilityMeasure μ
⊢ snormEssSup f μ * ↑↑μ Set.univ ^ (1 / q) = snormEssSup f μ
Theorem: isArtinian_of_range_eq_ker
File: Mathlib/RingTheory/Artinian.lean

tactic: simp [Submodule.map_comap_eq, inf_comm]
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type u_4
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup P
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R M
inst✝³ : Module R P
inst✝² : Module R N
inst✝¹ : IsArtinian R M
inst✝ : IsArtinian R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hf : Function.Injective ↑f
hg : Function.Surjective ↑g
h : LinearMap.range f = LinearMap.ker g
⊢ ∀ (a : Submodule R N), Submodule.map f (Submodule.comap f a) = a ⊓ LinearMap.range f

tactic: simp [Submodule.comap_map_eq, h]
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type u_4
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup P
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R M
inst✝³ : Module R P
inst✝² : Module R N
inst✝¹ : IsArtinian R M
inst✝ : IsArtinian R P
f : M →ₗ[R] N
g : N →ₗ[R] P
hf : Function.Injective ↑f
hg : Function.Surjective ↑g
h : LinearMap.range f = LinearMap.ker g
⊢ ∀ (a : Submodule R N), Submodule.comap g (Submodule.map g a) = a ⊔ LinearMap.range f
Theorem: Finsupp.lcongr_symm_single
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: apply_fun (lcongr e₁ e₂ : (ι →₀ M) → (κ →₀ N)) using (lcongr e₁ e₂).injective
state_before: α : Type ?u.556480
M : Type u_4
N : Type u_5
P : Type ?u.556489
R : Type u_3
S : Type ?u.556495
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
ι : Type u_1
κ : Type u_2
e₁ : ι ≃ κ
e₂ : M ≃ₗ[R] N
k : κ
n : N
⊢ ↑(LinearEquiv.symm (lcongr e₁ e₂)) (single k n) = single (↑e₁.symm k) (↑(LinearEquiv.symm e₂) n)

tactic: simp
state_before: α : Type ?u.556480
M : Type u_4
N : Type u_5
P : Type ?u.556489
R : Type u_3
S : Type ?u.556495
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
ι : Type u_1
κ : Type u_2
e₁ : ι ≃ κ
e₂ : M ≃ₗ[R] N
k : κ
n : N
⊢ ↑(lcongr e₁ e₂) (↑(LinearEquiv.symm (lcongr e₁ e₂)) (single k n)) =
    ↑(lcongr e₁ e₂) (single (↑e₁.symm k) (↑(LinearEquiv.symm e₂) n))
Theorem: imageSubobjectIso_imageToKernel'
File: Mathlib/Algebra/Homology/ImageToKernel.lean

tactic: apply equalizer.hom_ext
state_before: ι : Type ?u.276606
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
w✝ : f ≫ g = 0
inst✝¹ : HasKernels V
inst✝ : HasImages V
w : f ≫ g = 0
⊢ (imageSubobjectIso f).hom ≫ imageToKernel' f g w = imageToKernel f g w ≫ (kernelSubobjectIso g).hom

tactic: simp [imageToKernel']
state_before: case h
ι : Type ?u.276606
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
A B C : V
f : A ⟶ B
g : B ⟶ C
w✝ : f ≫ g = 0
inst✝¹ : HasKernels V
inst✝ : HasImages V
w : f ≫ g = 0
⊢ ((imageSubobjectIso f).hom ≫ imageToKernel' f g w) ≫ equalizer.ι g 0 =
    (imageToKernel f g w ≫ (kernelSubobjectIso g).hom) ≫ equalizer.ι g 0
Theorem: Finset.multiplicativeEnergy_empty_right
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: simp [multiplicativeEnergy]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ multiplicativeEnergy s ∅ = 0
Theorem: tendsto_multiset_prod
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: rcases s with ⟨l⟩
state_before: ι : Type u_2
α : Type u_1
X : Type ?u.408366
M : Type u_3
N : Type ?u.408372
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → α → M
x : Filter α
a : ι → M
s : Multiset ι
⊢ (∀ (i : ι), i ∈ s → Tendsto (f i) x (𝓝 (a i))) →
    Tendsto (fun b => Multiset.prod (Multiset.map (fun c => f c b) s)) x (𝓝 (Multiset.prod (Multiset.map a s)))

tactic: simpa using tendsto_list_prod l
state_before: case mk
ι : Type u_2
α : Type u_1
X : Type ?u.408366
M : Type u_3
N : Type ?u.408372
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : CommMonoid M
inst✝ : ContinuousMul M
f : ι → α → M
x : Filter α
a : ι → M
s : Multiset ι
l : List ι
⊢ (∀ (i : ι), i ∈ Quot.mk Setoid.r l → Tendsto (f i) x (𝓝 (a i))) →
    Tendsto (fun b => Multiset.prod (Multiset.map (fun c => f c b) (Quot.mk Setoid.r l))) x
      (𝓝 (Multiset.prod (Multiset.map a (Quot.mk Setoid.r l))))
Theorem: SetLike.list_prod_ofFn_mem_graded
File: Mathlib/Algebra/GradedMonoid.lean

tactic: rw [List.ofFn_eq_map, List.ofFn_eq_map]
state_before: ι : Type u_3
R : Type u_1
S : Type u_2
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
i : Fin n → ι
r : Fin n → R
h : ∀ (j : Fin n), r j ∈ A (i j)
⊢ List.prod (List.ofFn r) ∈ A (List.sum (List.ofFn i))

tactic: exact list_prod_map_mem_graded _ _ _ fun _ _ => h _
state_before: ι : Type u_3
R : Type u_1
S : Type u_2
inst✝³ : SetLike S R
inst✝² : Monoid R
inst✝¹ : AddMonoid ι
A : ι → S
inst✝ : GradedMonoid A
n : ℕ
i : Fin n → ι
r : Fin n → R
h : ∀ (j : Fin n), r j ∈ A (i j)
⊢ List.prod (List.map r (List.finRange n)) ∈ A (List.sum (List.map i (List.finRange n)))
Theorem: Dfinsupp.mapRange_zero
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
⊢ mapRange f hf 0 = 0

tactic: simp only [mapRange_apply, coe_zero, Pi.zero_apply, hf]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i
hf : ∀ (i : ι), f i 0 = 0
i✝ : ι
⊢ ↑(mapRange f hf 0) i✝ = ↑0 i✝
Theorem: MeasureTheory.Integrable.abs
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hf⊢
state_before: α : Type u_2
β✝ : Type ?u.955189
γ : Type ?u.955192
δ : Type ?u.955195
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_1
inst✝ : NormedLatticeAddCommGroup β
f : α → β
hf : Integrable f
⊢ Integrable fun a => Abs.abs (f a)

tactic: exact hf.abs
state_before: α : Type u_2
β✝ : Type ?u.955189
γ : Type ?u.955192
δ : Type ?u.955195
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β✝
inst✝¹ : NormedAddCommGroup γ
β : Type u_1
inst✝ : NormedLatticeAddCommGroup β
f : α → β
hf : Memℒp f 1
⊢ Memℒp (fun a => Abs.abs (f a)) 1
Theorem: MeasureTheory.MeasurePreserving.restrict_image_emb
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: simpa only [Set.preimage_image_eq _ h₂.injective] using hf.restrict_preimage_emb h₂ (f '' s)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.53205
δ : Type ?u.53208
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
f : α → β
hf : MeasurePreserving f
h₂ : MeasurableEmbedding f
s : Set α
⊢ MeasurePreserving f
Theorem: Set.image_update_Ico_left
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simpa using image_update_Ico f i a (f i)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → PartialOrder (α i)
f : (i : ι) → α i
i : ι
a : α i
⊢ update f i '' Ico a (f i) = Ico (update f i a) f
Theorem: IntermediateField.algHom_mk_adjoin_splits
File: Mathlib/FieldTheory/Adjoin.lean

tactic: obtain ⟨x : Lifts F E K, hx⟩ := zorn_partialOrder Lifts.exists_upper_bound
state_before: F : Type u_2
E : Type u_1
K : Type u_3
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
hK : ∀ (s : E), s ∈ S → IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)
⊢ Nonempty ({ x // x ∈ adjoin F S } →ₐ[F] K)

tactic: refine'
  ⟨{ toFun := (fun s => x.2 ⟨s, adjoin_le_iff.mpr (fun s hs => _) s.mem⟩)
     map_one' := x.2.map_one
     map_mul' := (fun s t => x.2.map_mul ⟨s, _⟩ ⟨t, _⟩)
     map_zero' := x.2.map_zero
     map_add' := (fun s t => x.2.map_add ⟨s, _⟩ ⟨t, _⟩)
     commutes' := x.2.commutes }⟩
state_before: case intro
F : Type u_2
E : Type u_1
K : Type u_3
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
hK : ∀ (s : E), s ∈ S → IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)
x : Lifts F E K
hx : ∀ (a : Lifts F E K), x ≤ a → a = x
⊢ Nonempty ({ x // x ∈ adjoin F S } →ₐ[F] K)

tactic: rcases x.exists_lift_of_splits (hK s hs).1 (hK s hs).2 with ⟨y, h1, h2⟩
state_before: case intro
F : Type u_2
E : Type u_1
K : Type u_3
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
hK : ∀ (s : E), s ∈ S → IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)
x : Lifts F E K
hx : ∀ (a : Lifts F E K), x ≤ a → a = x
s✝ : { x // x ∈ adjoin F S }
s : E
hs : s ∈ S
⊢ s ∈ ↑x.fst

tactic: rwa [hx y h1] at h2
state_before: case intro.intro.intro
F : Type u_2
E : Type u_1
K : Type u_3
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Field K
inst✝¹ : Algebra F E
inst✝ : Algebra F K
S : Set E
hK : ∀ (s : E), s ∈ S → IsIntegral F s ∧ Splits (algebraMap F K) (minpoly F s)
x : Lifts F E K
hx : ∀ (a : Lifts F E K), x ≤ a → a = x
s✝ : { x // x ∈ adjoin F S }
s : E
hs : s ∈ S
y : Lifts F E K
h1 : x ≤ y
h2 : s ∈ y.fst
⊢ s ∈ ↑x.fst
Theorem: List.foldl_eq_of_comm_of_assoc
File: Mathlib/Data/List/Basic.lean

tactic: simp only [foldl_cons]
state_before: ι : Type ?u.249050
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f a (b :: c :: l) = f b (foldl f a (c :: l))

tactic: rw [← foldl_eq_of_comm_of_assoc .., right_comm _ hcomm hassoc]
state_before: ι : Type ?u.249050
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f (f (f a b) c) l = f b (foldl f (f a c) l)

tactic: rfl
state_before: ι : Type ?u.249050
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α → α
hcomm : Commutative f
hassoc : Associative f
a b c : α
l : List α
⊢ foldl f (f (f a c) b) l = foldl f (f a c) (b :: l)
Theorem: MonotoneOn.integral_le_sum_Ico
File: Mathlib/Analysis/SumIntegralComparisons.lean

tactic: rw [← neg_le_neg_iff, ← Finset.sum_neg_distrib, ← intervalIntegral.integral_neg]
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : MonotoneOn f (Icc ↑a ↑b)
⊢ (∫ (x : ℝ) in ↑a..↑b, f x) ≤ ∑ i in Finset.Ico a b, f ↑(i + 1)

tactic: exact hf.neg.sum_le_integral_Ico hab
state_before: x₀ : ℝ
a b : ℕ
f : ℝ → ℝ
hab : a ≤ b
hf : MonotoneOn f (Icc ↑a ↑b)
⊢ ∑ x in Finset.Ico a b, -f ↑(x + 1) ≤ ∫ (x : ℝ) in ↑a..↑b, -f x
Theorem: FreeAlgebra.star_algebraMap
File: Mathlib/Algebra/Star/Free.lean

tactic: simp [star, Star.star]
state_before: R : Type u_1
inst✝ : CommSemiring R
X : Type u_2
r : R
⊢ star (↑(algebraMap R (FreeAlgebra R X)) r) = ↑(algebraMap R (FreeAlgebra R X)) r
Theorem: Cardinal.infinite_pigeonhole_card_lt
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simp_rw [← succ_le_iff]
state_before: α✝ : Type ?u.148026
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
w : (#α) < (#β)
w' : ℵ₀ ≤ (#α)
⊢ ∃ a, (#α) < (#↑(f ⁻¹' {a}))

tactic: exact
  Ordinal.infinite_pigeonhole_card f (succ (#α)) (succ_le_of_lt w) (w'.trans (lt_succ _).le)
    ((lt_succ _).trans_le (isRegular_succ w').2.ge)
state_before: α✝ : Type ?u.148026
r : α✝ → α✝ → Prop
β α : Type u
f : β → α
w : (#α) < (#β)
w' : ℵ₀ ≤ (#α)
⊢ ∃ a, succ (#α) ≤ (#↑(f ⁻¹' {a}))
Theorem: MultilinearMap.mkPiRing_zero
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: ext
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
⊢ MultilinearMap.mkPiRing R ι 0 = 0

tactic: rw [mkPiRing_apply, smul_zero, MultilinearMap.zero_apply]
state_before: case H
R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁵ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁴ : AddCommMonoid M₂
inst✝³ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝² : (i : ι) → Module R (M₁ i)
inst✝¹ : Module R M₂
f f' : MultilinearMap R M₁ M₂
inst✝ : Fintype ι
x✝ : ι → R
⊢ ↑(MultilinearMap.mkPiRing R ι 0) x✝ = ↑0 x✝
Theorem: RingEquiv.coe_ringHom_inj_iff
File: Mathlib/Algebra/Ring/Equiv.lean

tactic: rw [h]
state_before: F : Type ?u.91573
α : Type ?u.91576
β : Type ?u.91579
R✝ : Type ?u.91582
S✝ : Type ?u.91585
S' : Type ?u.91588
inst✝⁴ : NonAssocSemiring R✝
inst✝³ : NonAssocSemiring S✝
inst✝² : NonAssocSemiring S'
R : Type u_1
S : Type u_2
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
f g : R ≃+* S
h : f = g
⊢ ↑f = ↑g
Theorem: Ordinal.typein_enum
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: let ⟨a, e⟩ := typein_surj r h
state_before: α : Type u_1
β : Type ?u.96934
γ : Type ?u.96937
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
o : Ordinal
h : o < type r
⊢ typein r (enum r o h) = o

tactic: subst e
state_before: α : Type u_1
β : Type ?u.96934
γ : Type ?u.96937
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
o : Ordinal
h : o < type r
a : α
e : typein r a = o
⊢ typein r (enum r o h) = o

tactic: rw [enum_typein]
state_before: α : Type u_1
β : Type ?u.96934
γ : Type ?u.96937
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
a : α
h : typein r a < type r
⊢ typein r (enum r (typein r a) h) = typein r a
Theorem: strictMono_iff_map_pos
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: refine ⟨fun h a => ?_, fun h a b hl => ?_⟩
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.52366
δ : Type ?u.52369
inst✝³ : OrderedAddCommGroup α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : AddMonoidHomClass F α β
f : F
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1
⊢ StrictMono ↑f ↔ ∀ (a : α), 0 < a → 0 < ↑f a

tactic: rw [← map_zero f]
state_before: case refine_1
F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.52366
δ : Type ?u.52369
inst✝³ : OrderedAddCommGroup α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : AddMonoidHomClass F α β
f : F
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1
h : StrictMono ↑f
a : α
⊢ 0 < a → 0 < ↑f a

tactic: apply h
state_before: case refine_1
F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.52366
δ : Type ?u.52369
inst✝³ : OrderedAddCommGroup α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : AddMonoidHomClass F α β
f : F
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1
h : StrictMono ↑f
a : α
⊢ 0 < a → ↑f 0 < ↑f a

tactic: rw [← sub_add_cancel b a, map_add f]
state_before: case refine_2
F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.52366
δ : Type ?u.52369
inst✝³ : OrderedAddCommGroup α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : AddMonoidHomClass F α β
f : F
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1
h : ∀ (a : α), 0 < a → 0 < ↑f a
a b : α
hl : a < b
⊢ ↑f a < ↑f b

tactic: exact lt_add_of_pos_left _ (h _ <| sub_pos.2 hl)
state_before: case refine_2
F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.52366
δ : Type ?u.52369
inst✝³ : OrderedAddCommGroup α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : AddMonoidHomClass F α β
f : F
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1
h : ∀ (a : α), 0 < a → 0 < ↑f a
a b : α
hl : a < b
⊢ ↑f a < ↑f (b - a) + ↑f a
Theorem: List.nth_le_inits
File: Mathlib/Data/List/Infix.lean

tactic: induction' l with x l IH generalizing n
state_before: α : Type u_1
β : Type ?u.50980
l✝ l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
l : List α
n : ℕ
hn : n < length (inits l)
⊢ nthLe (inits l) n hn = take n l

tactic: simp
state_before: case nil
α : Type u_1
β : Type ?u.50980
l✝ l₁ l₂ l₃ : List α
a b : α
m n✝¹ : ℕ
l : List α
n✝ : ℕ
hn✝ : n✝ < length (inits l)
n : ℕ
hn : n < length (inits [])
⊢ nthLe (inits []) n hn = take n []

tactic: cases n
state_before: case cons
α : Type u_1
β : Type ?u.50980
l✝¹ l₁ l₂ l₃ : List α
a b : α
m n✝¹ : ℕ
l✝ : List α
n✝ : ℕ
hn✝ : n✝ < length (inits l✝)
x : α
l : List α
IH : ∀ (n : ℕ) (hn : n < length (inits l)), nthLe (inits l) n hn = take n l
n : ℕ
hn : n < length (inits (x :: l))
⊢ nthLe (inits (x :: l)) n hn = take n (x :: l)

tactic: simp[nthLe_cons]
state_before: case cons.zero
α : Type u_1
β : Type ?u.50980
l✝¹ l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
l✝ : List α
n : ℕ
hn✝ : n < length (inits l✝)
x : α
l : List α
IH : ∀ (n : ℕ) (hn : n < length (inits l)), nthLe (inits l) n hn = take n l
hn : zero < length (inits (x :: l))
⊢ nthLe (inits (x :: l)) zero hn = take zero (x :: l)

tactic: simpa[nthLe_cons] using IH _ _
state_before: case cons.succ
α : Type u_1
β : Type ?u.50980
l✝¹ l₁ l₂ l₃ : List α
a b : α
m n✝¹ : ℕ
l✝ : List α
n : ℕ
hn✝ : n < length (inits l✝)
x : α
l : List α
IH : ∀ (n : ℕ) (hn : n < length (inits l)), nthLe (inits l) n hn = take n l
n✝ : ℕ
hn : succ n✝ < length (inits (x :: l))
⊢ nthLe (inits (x :: l)) (succ n✝) hn = take (succ n✝) (x :: l)
Theorem: inv_le_inv_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_le_mul_iff_left a, ← mul_le_mul_iff_right b]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a⁻¹ ≤ b⁻¹ ↔ b ≤ a

tactic: simp
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * a⁻¹ * b ≤ a * b⁻¹ * b ↔ b ≤ a
Theorem: ProjectiveSpectrum.basicOpen_pow
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: simpa using zeroLocus_singleton_pow 𝒜 f n hn
state_before: R : Type u_2
A : Type u_1
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
n : ℕ
hn : 0 < n
⊢ ↑(basicOpen 𝒜 (f ^ n)) = ↑(basicOpen 𝒜 f)
Theorem: Ideal.quotient_map_comp_mkₐ
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: simp only [quotient_map_mkₐ, Quotient.mkₐ_eq_mk, AlgHom.comp_apply]
state_before: R : Type u
S : Type v
F : Type w
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
R₁ : Type u_3
R₂ : Type ?u.1587950
A : Type u_1
B : Type u_2
inst✝⁶ : CommSemiring R₁
inst✝⁵ : CommSemiring R₂
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R₁ A
inst✝¹ : Algebra R₂ A
inst✝ : Algebra R₁ B
I : Ideal A
J : Ideal B
f : A →ₐ[R₁] B
H : I ≤ comap f J
x : A
⊢ ↑(AlgHom.comp (quotientMapₐ J f H) (Quotient.mkₐ R₁ I)) x = ↑(AlgHom.comp (Quotient.mkₐ R₁ J) f) x