tasksource/leandojo huggingface dataset:
Theorem: irrational_rat_div_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: simp [div_eq_mul_inv]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (↑q / x) ↔ q ≠ 0 ∧ Irrational x
Theorem: mul_inv_le_of_le_mul
File: Mathlib/Algebra/Order/WithZero.lean

tactic: by_cases h : c = 0
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
hab : a ≤ b * c
⊢ a * c⁻¹ ≤ b

tactic: simp [h]
state_before: case pos
α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
hab : a ≤ b * c
h : c = 0
⊢ a * c⁻¹ ≤ b

tactic: exact le_of_le_mul_right h (by simpa [h] using hab)
state_before: case neg
α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
hab : a ≤ b * c
h : ¬c = 0
⊢ a * c⁻¹ ≤ b

tactic: simpa [h] using hab
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
hab : a ≤ b * c
h : ¬c = 0
⊢ a * c⁻¹ * c ≤ b * c
Theorem: MeasureTheory.exists_pos_measure_of_cover
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: contrapose! hμ with H
state_before: α : Type u_2
β : Type ?u.836823
γ : Type ?u.836826
δ : Type ?u.836829
ι : Type u_1
R : Type ?u.836835
R' : Type ?u.836838
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : Countable ι
U : ι → Set α
hU : (⋃ (i : ι), U i) = univ
hμ : μ ≠ 0
⊢ ∃ i, 0 < ↑↑μ (U i)

tactic: rw [← measure_univ_eq_zero, ← hU]
state_before: α : Type u_2
β : Type ?u.836823
γ : Type ?u.836826
δ : Type ?u.836829
ι : Type u_1
R : Type ?u.836835
R' : Type ?u.836838
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : Countable ι
U : ι → Set α
hU : (⋃ (i : ι), U i) = univ
H : ∀ (i : ι), ↑↑μ (U i) ≤ 0
⊢ μ = 0

tactic: exact measure_iUnion_null fun i => nonpos_iff_eq_zero.1 (H i)
state_before: α : Type u_2
β : Type ?u.836823
γ : Type ?u.836826
δ : Type ?u.836829
ι : Type u_1
R : Type ?u.836835
R' : Type ?u.836838
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : Countable ι
U : ι → Set α
hU : (⋃ (i : ι), U i) = univ
H : ∀ (i : ι), ↑↑μ (U i) ≤ 0
⊢ ↑↑μ (⋃ (i : ι), U i) = 0
Theorem: Pi.mulSupport_mulSingle
File: Mathlib/Algebra/Support.lean

tactic: split_ifs with h <;> simp [h]
state_before: A : Type u_2
B : Type u_1
inst✝² : DecidableEq A
inst✝¹ : One B
a : A
b : B
inst✝ : DecidableEq B
⊢ mulSupport (mulSingle a b) = if b = 1 then ∅ else {a}
Theorem: rtendsto'_nhds
File: Mathlib/Topology/Partial.lean

tactic: rw [rtendsto'_def]
state_before: α : Type u_2
β : Type u_1
inst✝ : TopologicalSpace α
r : Rel β α
l : Filter β
a : α
⊢ RTendsto' r l (𝓝 a) ↔ ∀ (s : Set α), IsOpen s → a ∈ s → Rel.preimage r s ∈ l

tactic: apply all_mem_nhds_filter
state_before: α : Type u_2
β : Type u_1
inst✝ : TopologicalSpace α
r : Rel β α
l : Filter β
a : α
⊢ (∀ (s : Set α), s ∈ 𝓝 a → Rel.preimage r s ∈ l) ↔ ∀ (s : Set α), IsOpen s → a ∈ s → Rel.preimage r s ∈ l

tactic: apply Rel.preimage_mono
state_before: case hf
α : Type u_2
β : Type u_1
inst✝ : TopologicalSpace α
r : Rel β α
l : Filter β
a : α
⊢ ∀ (s t : Set α), s ⊆ t → Rel.preimage r s ⊆ Rel.preimage r t
Theorem: MvPowerSeries.coeff_monomial_same
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [monomial_def]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
n : σ →₀ ℕ
a : R
⊢ ↑(coeff R n) (↑(monomial R n) a) = a

tactic: exact LinearMap.stdBasis_same R (fun _ ↦ R) n a
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
n : σ →₀ ℕ
a : R
⊢ ↑(coeff R n) (↑(LinearMap.stdBasis R (fun x => R) n) a) = a
Theorem: Finset.sup_comm
File: Mathlib/Data/Finset/Lattice.lean

tactic: refine' eq_of_forall_ge_iff fun a => _
state_before: F : Type ?u.52740
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.52752
κ : Type ?u.52755
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g : β → α
a : α
s : Finset β
t : Finset γ
f : β → γ → α
⊢ (sup s fun b => sup t (f b)) = sup t fun c => sup s fun b => f b c

tactic: simp_rw [Finset.sup_le_iff]
state_before: F : Type ?u.52740
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.52752
κ : Type ?u.52755
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g : β → α
a✝ : α
s : Finset β
t : Finset γ
f : β → γ → α
a : α
⊢ (sup s fun b => sup t (f b)) ≤ a ↔ (sup t fun c => sup s fun b => f b c) ≤ a

tactic: exact ⟨fun h c hc b hb => h b hb c hc, fun h b hb c hc => h c hc b hb⟩
state_before: F : Type ?u.52740
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.52752
κ : Type ?u.52755
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g : β → α
a✝ : α
s : Finset β
t : Finset γ
f : β → γ → α
a : α
⊢ (∀ (b : β), b ∈ s → ∀ (b_1 : γ), b_1 ∈ t → f b b_1 ≤ a) ↔ ∀ (b : γ), b ∈ t → ∀ (b_1 : β), b_1 ∈ s → f b_1 b ≤ a
Theorem: Finset.card_div_mul_le_card_div_mul_card_div
File: Mathlib/Combinatorics/Additive/PluenneckeRuzsa.lean

tactic: rw [← card_product (A / B), ← mul_one ((A / B) ×ˢ (B / C)).card]
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A / C) * card B ≤ card (A / B) * card (B / C)

tactic: refine' card_mul_le_card_mul (fun b ac ↦ ac.1 * ac.2 = b) (fun x hx ↦ _)
  fun x _ ↦ card_le_one_iff.2 fun hu hv ↦
    ((mem_bipartiteBelow _).1 hu).2.symm.trans ((mem_bipartiteBelow _).1 hv).2
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
⊢ card (A / C) * card B ≤ card ((A / B) ×ˢ (B / C)) * 1

tactic: obtain ⟨a, c, ha, hc, rfl⟩ := mem_div.1 hx
state_before: α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
x : α
hx : x ∈ A / C
⊢ card B ≤ card (bipartiteAbove (fun b ac => ac.fst * ac.snd = b) ((A / B) ×ˢ (B / C)) x)

tactic: refine' card_le_card_of_inj_on (fun b ↦ (a / b, b / c)) (fun b hb ↦ _) fun b₁ _ b₂ _ h ↦ _
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
a c : α
ha : a ∈ A
hc : c ∈ C
hx : a / c ∈ A / C
⊢ card B ≤ card (bipartiteAbove (fun b ac => ac.fst * ac.snd = b) ((A / B) ×ˢ (B / C)) (a / c))

tactic: rw [mem_bipartiteAbove]
state_before: case intro.intro.intro.intro.refine'_1
α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
a c : α
ha : a ∈ A
hc : c ∈ C
hx : a / c ∈ A / C
b : α
hb : b ∈ B
⊢ (fun b => (a / b, b / c)) b ∈ bipartiteAbove (fun b ac => ac.fst * ac.snd = b) ((A / B) ×ˢ (B / C)) (a / c)

tactic: exact ⟨mk_mem_product (div_mem_div ha hb) (div_mem_div hb hc), div_mul_div_cancel' _ _ _⟩
state_before: case intro.intro.intro.intro.refine'_1
α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
a c : α
ha : a ∈ A
hc : c ∈ C
hx : a / c ∈ A / C
b : α
hb : b ∈ B
⊢ (fun b => (a / b, b / c)) b ∈ (A / B) ×ˢ (B / C) ∧
    ((fun b => (a / b, b / c)) b).fst * ((fun b => (a / b, b / c)) b).snd = a / c

tactic: exact div_right_injective (Prod.ext_iff.1 h).1
state_before: case intro.intro.intro.intro.refine'_2
α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A✝ B✝ C✝ A B C : Finset α
a c : α
ha : a ∈ A
hc : c ∈ C
hx : a / c ∈ A / C
b₁ : α
x✝¹ : b₁ ∈ B
b₂ : α
x✝ : b₂ ∈ B
h : (fun b => (a / b, b / c)) b₁ = (fun b => (a / b, b / c)) b₂
⊢ b₁ = b₂
Theorem: Matrix.toLin_finTwoProd_apply
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: simp [Matrix.toLin_apply, Matrix.mulVec, Matrix.dotProduct, (Prod.smul_mk)]
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type ?u.2864957
m : Type ?u.2864960
n : Type ?u.2864963
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type ?u.2864981
M₂ : Type ?u.2864984
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2865486
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
a b c d : R
x : R × R
⊢ ↑(↑(toLin (Basis.finTwoProd R) (Basis.finTwoProd R)) (↑of ![![a, b], ![c, d]])) x =
    (a * x.fst + b * x.snd, c * x.fst + d * x.snd)
Theorem: Units.pow_ofPowEqOne
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: simp [hx]
state_before: α : Type ?u.50460
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : AddMonoid A
inst✝ : AddMonoid B
x : M
n : ℕ
hx : x ^ n = 1
hn : n ≠ 0
⊢ ↑(ofPowEqOne x n hx hn ^ n) = ↑1
Theorem: Num.of_nat_cast
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_nat, to_of_nat]
state_before: α : Type u_1
inst✝ : AddMonoidWithOne α
n : ℕ
⊢ ↑↑n = ↑n
Theorem: intervalIntegral.integral_hasStrictDerivAt_left
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa only [← integral_symm] using (integral_hasStrictDerivAt_right hf.symm hmeas ha).neg
state_before: ι : Type ?u.1682730
𝕜 : Type ?u.1682733
E : Type u_1
F : Type ?u.1682739
A : Type ?u.1682742
inst✝⁴ : NormedAddCommGroup E
inst✝³ : CompleteSpace E
inst✝² : NormedSpace ℝ E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hf : IntervalIntegrable f volume a b
hmeas : StronglyMeasurableAtFilter f (𝓝 a)
ha : ContinuousAt f a
⊢ HasStrictDerivAt (fun u => ∫ (x : ℝ) in u..b, f x) (-f a) a
Theorem: Nat.lt_size_self
File: Mathlib/Data/Nat/Size.lean

tactic: rw [← one_shiftl]
state_before: n : ℕ
⊢ n < 2 ^ size n

tactic: have : ∀ {n}, n = 0 → n < shiftl 1 (size n) := by simp
state_before: n : ℕ
⊢ n < shiftl 1 (size n)

tactic: apply binaryRec _ _ n
state_before: n : ℕ
this : ∀ {n : ℕ}, n = 0 → n < shiftl 1 (size n)
⊢ n < shiftl 1 (size n)

tactic: intro b n IH
state_before: n : ℕ
this : ∀ {n : ℕ}, n = 0 → n < shiftl 1 (size n)
⊢ ∀ (b : Bool) (n : ℕ), n < shiftl 1 (size n) → bit b n < shiftl 1 (size (bit b n))

tactic: by_cases h : bit b n = 0
state_before: n✝ : ℕ
this : ∀ {n : ℕ}, n = 0 → n < shiftl 1 (size n)
b : Bool
n : ℕ
IH : n < shiftl 1 (size n)
⊢ bit b n < shiftl 1 (size (bit b n))

tactic: rw [size_bit h, shiftl_succ]
state_before: case neg
n✝ : ℕ
this : ∀ {n : ℕ}, n = 0 → n < shiftl 1 (size n)
b : Bool
n : ℕ
IH : n < shiftl 1 (size n)
h : ¬bit b n = 0
⊢ bit b n < shiftl 1 (size (bit b n))

tactic: exact bit_lt_bit0 _ IH
state_before: case neg
n✝ : ℕ
this : ∀ {n : ℕ}, n = 0 → n < shiftl 1 (size n)
b : Bool
n : ℕ
IH : n < shiftl 1 (size n)
h : ¬bit b n = 0
⊢ bit b n < bit0 (shiftl 1 (size n))

tactic: simp
state_before: n : ℕ
⊢ ∀ {n : ℕ}, n = 0 → n < shiftl 1 (size n)

tactic: apply this rfl
state_before: n : ℕ
this : ∀ {n : ℕ}, n = 0 → n < shiftl 1 (size n)
⊢ 0 < shiftl 1 (size 0)

tactic: apply this h
state_before: case pos
n✝ : ℕ
this : ∀ {n : ℕ}, n = 0 → n < shiftl 1 (size n)
b : Bool
n : ℕ
IH : n < shiftl 1 (size n)
h : bit b n = 0
⊢ bit b n < shiftl 1 (size (bit b n))
Theorem: Submodule.le_span_singleton_iff
File: Mathlib/LinearAlgebra/Span.lean

tactic: simp_rw [SetLike.le_def, mem_span_singleton]
state_before: R : Type u_1
R₂ : Type ?u.120610
K : Type ?u.120613
M : Type u_2
M₂ : Type ?u.120619
V : Type ?u.120622
S : Type ?u.120625
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s✝ t : Set M
s : Submodule R M
v₀ : M
⊢ s ≤ span R {v₀} ↔ ∀ (v : M), v ∈ s → ∃ r, r • v₀ = v
Theorem: Multiset.add_eq_union_right_of_le
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simpa only [and_comm] using add_eq_union_left_of_le h
state_before: ι : Type ?u.903489
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : DecidableEq α
x y z : Multiset α
h : z ≤ y
⊢ x + y = x ∪ z ↔ y = z ∧ Disjoint x y
Theorem: sub_smul
File: Mathlib/Algebra/Module/Basic.lean

tactic: simp [add_smul, sub_eq_add_neg]
state_before: α : Type ?u.115990
R : Type u_2
k : Type ?u.115996
S : Type ?u.115999
M : Type u_1
M₂ : Type ?u.116005
M₃ : Type ?u.116008
ι : Type ?u.116011
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
r✝ s✝ : R
x y✝ : M
r s : R
y : M
⊢ (r - s) • y = r • y - s • y
Theorem: inf_sup_right
File: Mathlib/Order/Lattice.lean

tactic: simp only [inf_sup_left, fun y : α => @inf_comm α _ y x, eq_self_iff_true]
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
⊢ (y ⊔ z) ⊓ x = y ⊓ x ⊔ z ⊓ x
Theorem: Polynomial.natDegree_add_le_iff_right
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: rw [add_comm]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q✝ r : R[X]
n : ℕ
p q : R[X]
pn : natDegree p ≤ n
⊢ natDegree (p + q) ≤ n ↔ natDegree q ≤ n

tactic: exact natDegree_add_le_iff_left _ _ pn
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q✝ r : R[X]
n : ℕ
p q : R[X]
pn : natDegree p ≤ n
⊢ natDegree (q + p) ≤ n ↔ natDegree q ≤ n
Theorem: Cubic.eq_prod_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [map_toPoly,
  eq_prod_roots_of_splits <|
    (splits_iff_roots_eq_three ha).mpr <| Exists.intro x <| Exists.intro y <| Exists.intro z h3,
  leadingCoeff_of_a_ne_zero ha, ← map_roots, h3]
state_before: R : Type ?u.715676
S : Type ?u.715679
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ toPoly (map φ P) = ↑C (↑φ P.a) * (X - ↑C x) * (X - ↑C y) * (X - ↑C z)

tactic: change C (φ P.a) * ((X - C x) ::ₘ (X - C y) ::ₘ {X - C z}).prod = _
state_before: R : Type ?u.715676
S : Type ?u.715679
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ ↑C (↑φ P.a) * prod (Multiset.map (fun a => X - ↑C a) {x, y, z}) = ↑C (↑φ P.a) * (X - ↑C x) * (X - ↑C y) * (X - ↑C z)

tactic: rw [prod_cons, prod_cons, prod_singleton, mul_assoc, mul_assoc]
state_before: R : Type ?u.715676
S : Type ?u.715679
F : Type u_1
K : Type u_2
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
⊢ ↑C (↑φ P.a) * prod ((X - ↑C x) ::ₘ (X - ↑C y) ::ₘ {X - ↑C z}) = ↑C (↑φ P.a) * (X - ↑C x) * (X - ↑C y) * (X - ↑C z)
Theorem: symmDiff_of_ge
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff, sdiff_eq_bot_iff.2 h, sup_bot_eq]
state_before: ι : Type ?u.20569
α : Type u_1
β : Type ?u.20575
π : ι → Type ?u.20580
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
h : b ≤ a
⊢ a ∆ b = a \ b
Theorem: DirectSum.mul_one
File: Mathlib/Algebra/DirectSum/Ring.lean

tactic: suffices (mulHom A).flip One.one = AddMonoidHom.id (⨁ i, A i) from FunLike.congr_fun this x
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
x : ⨁ (i : ι), A i
⊢ x * 1 = x

tactic: apply addHom_ext
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
x : ⨁ (i : ι), A i
⊢ ↑(AddMonoidHom.flip (mulHom A)) One.one = AddMonoidHom.id (⨁ (i : ι), A i)

tactic: intro i xi
state_before: case H
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
x : ⨁ (i : ι), A i
⊢ ∀ (i : ι) (y : A i),
    ↑(↑(AddMonoidHom.flip (mulHom A)) One.one) (↑(of (fun i => A i) i) y) =
      ↑(AddMonoidHom.id (⨁ (i : ι), A i)) (↑(of (fun i => A i) i) y)

tactic: simp only [One.one]
state_before: case H
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
x : ⨁ (i : ι), A i
i : ι
xi : A i
⊢ ↑(↑(AddMonoidHom.flip (mulHom A)) One.one) (↑(of (fun i => A i) i) xi) =
    ↑(AddMonoidHom.id (⨁ (i : ι), A i)) (↑(of (fun i => A i) i) xi)

tactic: rw [flip_apply, mulHom_of_of]
state_before: case H
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
x : ⨁ (i : ι), A i
i : ι
xi : A i
⊢ ↑(↑(AddMonoidHom.flip (mulHom A)) (↑(of (fun i => A i) 0) GradedMonoid.GOne.one)) (↑(of (fun i => A i) i) xi) =
    ↑(AddMonoidHom.id (⨁ (i : ι), A i)) (↑(of (fun i => A i) i) xi)

tactic: exact of_eq_of_gradedMonoid_eq (mul_one <| GradedMonoid.mk i xi)
state_before: case H
ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
x : ⨁ (i : ι), A i
i : ι
xi : A i
⊢ ↑(of A (i + 0)) (GradedMonoid.GMul.mul xi GradedMonoid.GOne.one) =
    ↑(AddMonoidHom.id (⨁ (i : ι), A i)) (↑(of (fun i => A i) i) xi)
Theorem: Bool.or_assoc
File: src/lean/Init/SimpLemmas.lean

tactic: cases a <;> cases b <;> cases c <;> decide
state_before: a b c : Bool
⊢ (a || b || c) = (a || (b || c))
Theorem: SeminormedAddCommGroup.cauchySeq_of_le_geometric
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: simpa [dist_eq_norm] using h
state_before: α : Type u_1
β : Type ?u.576655
ι : Type ?u.576658
inst✝ : SeminormedAddCommGroup α
r✝ C✝ : ℝ
f : ℕ → α
C r : ℝ
hr : r < 1
u : ℕ → α
h : ∀ (n : ℕ), ‖u n - u (n + 1)‖ ≤ C * r ^ n
⊢ ∀ (n : ℕ), dist (u n) (u (n + 1)) ≤ C * r ^ n
Theorem: Ordinal.bmex_monotone
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rwa [range_familyOfBFamily, range_familyOfBFamily]
state_before: α : Type ?u.388606
β : Type ?u.388609
γ : Type ?u.388612
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o o' : Ordinal
f : (a : Ordinal) → a < o → Ordinal
g : (a : Ordinal) → a < o' → Ordinal
h : brange o f ⊆ brange o' g
⊢ range (familyOfBFamily o f) ⊆ range (familyOfBFamily o' g)
Theorem: Finite.one_lt_card_iff_nontrivial
File: Mathlib/Data/Finite/Card.lean

tactic: haveI := Fintype.ofFinite α
state_before: α : Type u_1
β : Type ?u.1718
γ : Type ?u.1721
inst✝ : Finite α
⊢ 1 < Nat.card α ↔ Nontrivial α

tactic: simp only [Nat.card_eq_fintype_card, Fintype.one_lt_card_iff_nontrivial]
state_before: α : Type u_1
β : Type ?u.1718
γ : Type ?u.1721
inst✝ : Finite α
this : Fintype α
⊢ 1 < Nat.card α ↔ Nontrivial α
Theorem: isBoundedBilinearMap_mul
File: Mathlib/Analysis/NormedSpace/BoundedLinearMaps.lean

tactic: simp_rw [← smul_eq_mul]
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type ?u.338526
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.338621
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.338711
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E × F → G
⊢ IsBoundedBilinearMap 𝕜 fun p => p.fst * p.snd

tactic: exact isBoundedBilinearMap_smul
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type ?u.338526
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type ?u.338621
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
G : Type ?u.338711
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f : E × F → G
⊢ IsBoundedBilinearMap 𝕜 fun p => p.fst • p.snd
Theorem: CategoryTheory.GrothendieckTopology.toImageSheaf_ι
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

tactic: ext1
state_before: C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F✝ F'✝ F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F✝
F F' : Sheaf J (Type w)
f : F ⟶ F'
⊢ toImageSheaf f ≫ imageSheafι f = f

tactic: simp [toImagePresheafSheafify]
state_before: case h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F✝ F'✝ F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F✝
F F' : Sheaf J (Type w)
f : F ⟶ F'
⊢ (toImageSheaf f ≫ imageSheafι f).val = f.val
Theorem: abs_sub_abs_le_abs_sub
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [sub_add_cancel]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ abs a = abs (a - b + b)
Theorem: List.sublists_perm_sublists'
File: Mathlib/Data/List/Sublists.lean

tactic: rw [← finRange_map_get l, sublists_map, sublists'_map]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ sublists l ~ sublists' l

tactic: refine' Perm.map _ _
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ map (map (get l)) (sublists (finRange (length l))) ~ map (map (get l)) (sublists' (finRange (length l)))

tactic: exact (perm_ext (nodup_sublists.2 (nodup_finRange _)) (nodup_sublists'.2 (nodup_finRange _))).2
  (by simp)
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ sublists (finRange (length l)) ~ sublists' (finRange (length l))

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ ∀ (a : List (Fin (length l))), a ∈ sublists (finRange (length l)) ↔ a ∈ sublists' (finRange (length l))
Theorem: Nat.ArithmeticFunction.vonMangoldt_apply_one
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: simp [vonMangoldt_apply]
state_before: ⊢ ↑Λ 1 = 0
Theorem: Fin.cycleRange_symm_zero
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: simp
state_before: n : ℕ
i : Fin (n + 1)
⊢ ↑(cycleRange i) (↑(cycleRange i).symm 0) = ↑(cycleRange i) i
Theorem: Mathlib.Meta.NormNum.isNat_natSub
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp
state_before: n✝¹ n✝ : ℕ
⊢ ↑n✝¹ - ↑n✝ = ↑(Nat.sub n✝¹ n✝)
Theorem: Prod.wcovby_iff
File: Mathlib/Order/Cover.lean

tactic: cases x
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ x ⩿ y ↔ x.fst ⩿ y.fst ∧ x.snd = y.snd ∨ x.snd ⩿ y.snd ∧ x.fst = y.fst

tactic: cases y
state_before: case mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
y : α × β
fst✝ : α
snd✝ : β
⊢ (fst✝, snd✝) ⩿ y ↔
    (fst✝, snd✝).fst ⩿ y.fst ∧ (fst✝, snd✝).snd = y.snd ∨ (fst✝, snd✝).snd ⩿ y.snd ∧ (fst✝, snd✝).fst = y.fst

tactic: exact mk_wcovby_mk_iff
state_before: case mk.mk
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
fst✝¹ : α
snd✝¹ : β
fst✝ : α
snd✝ : β
⊢ (fst✝¹, snd✝¹) ⩿ (fst✝, snd✝) ↔
    (fst✝¹, snd✝¹).fst ⩿ (fst✝, snd✝).fst ∧ (fst✝¹, snd✝¹).snd = (fst✝, snd✝).snd ∨
      (fst✝¹, snd✝¹).snd ⩿ (fst✝, snd✝).snd ∧ (fst✝¹, snd✝¹).fst = (fst✝, snd✝).fst
Theorem: Submonoid.list_prod_mem
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: lift l to List s using hl
state_before: M : Type u_1
A : Type ?u.25243
B : Type ?u.25246
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S : B
s : Submonoid M
l : List M
hl : ∀ (x : M), x ∈ l → x ∈ s
⊢ List.prod l ∈ s

tactic: rw [← coe_list_prod]
state_before: case intro
M : Type u_1
A : Type ?u.25243
B : Type ?u.25246
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S : B
s : Submonoid M
l : List { x // x ∈ s }
⊢ List.prod (List.map Subtype.val l) ∈ s

tactic: exact l.prod.coe_prop
state_before: case intro
M : Type u_1
A : Type ?u.25243
B : Type ?u.25246
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S : B
s : Submonoid M
l : List { x // x ∈ s }
⊢ ↑(List.prod l) ∈ s
Theorem: Int.ofNat_add_negSucc_of_lt
File: Std/Data/Int/Lemmas.lean

tactic: simp [succ_sub (le_of_lt_succ h), subNatNat]
state_before: m n : Nat
h : m < succ n
⊢ subNatNat m (succ n) = -[n - m+1]
Theorem: powersEquivPowers_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [powersEquivPowers, Equiv.trans_apply, Equiv.trans_apply, finEquivPowers_symm_apply, ←
  Equiv.eq_symm_apply, finEquivPowers_symm_apply]
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝² : LeftCancelMonoid G
inst✝¹ : AddLeftCancelMonoid A
inst✝ : Finite G
h : orderOf x = orderOf y
n : ℕ
⊢ ↑(powersEquivPowers h) { val := x ^ n, property := (_ : ∃ y, (fun x x_1 => x ^ x_1) x y = x ^ n) } =
    { val := y ^ n, property := (_ : ∃ y_1, (fun x x_1 => x ^ x_1) y y_1 = y ^ n) }

tactic: simp [h]
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝² : LeftCancelMonoid G
inst✝¹ : AddLeftCancelMonoid A
inst✝ : Finite G
h : orderOf x = orderOf y
n : ℕ
⊢ ↑(Fin.cast h).toEquiv { val := n % orderOf x, isLt := (_ : n % orderOf x < orderOf x) } =
    { val := n % orderOf y, isLt := (_ : n % orderOf y < orderOf y) }
Theorem: Submodule.eq_zero_of_coe_mem_of_disjoint
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: exact_mod_cast disjoint_def.mp hpq a (coe_mem a) ha
state_before: R : Type u_2
S : Type ?u.179265
M : Type u_1
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p q : Submodule R M
hpq : Disjoint p q
a : { x // x ∈ p }
ha : ↑a ∈ q
⊢ a = 0