tasksource/leandojo huggingface dataset:
Theorem: ne_one_of_norm_ne_zero
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rintro rfl
state_before: 𝓕 : Type ?u.73640
𝕜 : Type ?u.73643
α : Type ?u.73646
ι : Type ?u.73649
κ : Type ?u.73652
E : Type u_1
F : Type ?u.73658
G : Type ?u.73661
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ a = 1 → ‖a‖ = 0

tactic: exact norm_one'
state_before: 𝓕 : Type ?u.73640
𝕜 : Type ?u.73643
α : Type ?u.73646
ι : Type ?u.73649
κ : Type ?u.73652
E : Type u_1
F : Type ?u.73658
G : Type ?u.73661
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ ‖1‖ = 0
Theorem: exists_associated_mem_of_dvd_prod
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: simp [mt isUnit_iff_dvd_one.2 hp.not_unit]
state_before: α : Type u_1
β : Type ?u.13323
γ : Type ?u.13326
δ : Type ?u.13329
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
s : Multiset α
⊢ (∀ (r : α), r ∈ 0 → Prime r) → p ∣ Multiset.prod 0 → ∃ q, q ∈ 0 ∧ p ~ᵤ q

tactic: rw [Multiset.prod_cons] at hps
state_before: α : Type u_1
β : Type ?u.13323
γ : Type ?u.13326
δ : Type ?u.13329
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
s✝ : Multiset α
a : α
s : Multiset α
ih : (∀ (r : α), r ∈ s → Prime r) → p ∣ Multiset.prod s → ∃ q, q ∈ s ∧ p ~ᵤ q
hs : ∀ (r : α), r ∈ a ::ₘ s → Prime r
hps : p ∣ Multiset.prod (a ::ₘ s)
⊢ ∃ q, q ∈ a ::ₘ s ∧ p ~ᵤ q

tactic: cases' hp.dvd_or_dvd hps with h h
state_before: α : Type u_1
β : Type ?u.13323
γ : Type ?u.13326
δ : Type ?u.13329
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
s✝ : Multiset α
a : α
s : Multiset α
ih : (∀ (r : α), r ∈ s → Prime r) → p ∣ Multiset.prod s → ∃ q, q ∈ s ∧ p ~ᵤ q
hs : ∀ (r : α), r ∈ a ::ₘ s → Prime r
hps : p ∣ a * Multiset.prod s
⊢ ∃ q, q ∈ a ::ₘ s ∧ p ~ᵤ q

tactic: have hap := hs a (Multiset.mem_cons.2 (Or.inl rfl))
state_before: case inl
α : Type u_1
β : Type ?u.13323
γ : Type ?u.13326
δ : Type ?u.13329
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
s✝ : Multiset α
a : α
s : Multiset α
ih : (∀ (r : α), r ∈ s → Prime r) → p ∣ Multiset.prod s → ∃ q, q ∈ s ∧ p ~ᵤ q
hs : ∀ (r : α), r ∈ a ::ₘ s → Prime r
hps : p ∣ a * Multiset.prod s
h : p ∣ a
⊢ ∃ q, q ∈ a ::ₘ s ∧ p ~ᵤ q

tactic: exact ⟨a, Multiset.mem_cons_self a _, hp.associated_of_dvd hap h⟩
state_before: case inl
α : Type u_1
β : Type ?u.13323
γ : Type ?u.13326
δ : Type ?u.13329
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
s✝ : Multiset α
a : α
s : Multiset α
ih : (∀ (r : α), r ∈ s → Prime r) → p ∣ Multiset.prod s → ∃ q, q ∈ s ∧ p ~ᵤ q
hs : ∀ (r : α), r ∈ a ::ₘ s → Prime r
hps : p ∣ a * Multiset.prod s
h : p ∣ a
hap : Prime a
⊢ ∃ q, q ∈ a ::ₘ s ∧ p ~ᵤ q

tactic: rcases ih (fun r hr => hs _ (Multiset.mem_cons.2 (Or.inr hr))) h with ⟨q, hq₁, hq₂⟩
state_before: case inr
α : Type u_1
β : Type ?u.13323
γ : Type ?u.13326
δ : Type ?u.13329
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
s✝ : Multiset α
a : α
s : Multiset α
ih : (∀ (r : α), r ∈ s → Prime r) → p ∣ Multiset.prod s → ∃ q, q ∈ s ∧ p ~ᵤ q
hs : ∀ (r : α), r ∈ a ::ₘ s → Prime r
hps : p ∣ a * Multiset.prod s
h : p ∣ Multiset.prod s
⊢ ∃ q, q ∈ a ::ₘ s ∧ p ~ᵤ q

tactic: exact ⟨q, Multiset.mem_cons.2 (Or.inr hq₁), hq₂⟩
state_before: case inr.intro.intro
α : Type u_1
β : Type ?u.13323
γ : Type ?u.13326
δ : Type ?u.13329
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
s✝ : Multiset α
a : α
s : Multiset α
ih : (∀ (r : α), r ∈ s → Prime r) → p ∣ Multiset.prod s → ∃ q, q ∈ s ∧ p ~ᵤ q
hs : ∀ (r : α), r ∈ a ::ₘ s → Prime r
hps : p ∣ a * Multiset.prod s
h : p ∣ Multiset.prod s
q : α
hq₁ : q ∈ s
hq₂ : p ~ᵤ q
⊢ ∃ q, q ∈ a ::ₘ s ∧ p ~ᵤ q
Theorem: IsUnit.isRegular
File: Mathlib/Algebra/Regular/Basic.lean

tactic: rcases ua with ⟨a, rfl⟩
state_before: R : Type u_1
inst✝ : Monoid R
a b : R
ua : IsUnit a
⊢ IsRegular a

tactic: exact Units.isRegular a
state_before: case intro
R : Type u_1
inst✝ : Monoid R
b : R
a : Rˣ
⊢ IsRegular ↑a
Theorem: LinearMap.quotientInfEquivSupQuotient_symm_apply_eq_zero_iff
File: Mathlib/LinearAlgebra/Isomorphisms.lean

tactic: rw [_root_.map_zero, Quotient.mk_eq_zero, mem_comap, Submodule.coeSubtype]
state_before: R : Type u_1
M : Type u_2
M₂ : Type ?u.110628
M₃ : Type ?u.110631
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M
inst✝¹ : Module R M₂
inst✝ : Module R M₃
f : M →ₗ[R] M₂
p p' : Submodule R M
x : { x // x ∈ p ⊔ p' }
⊢ Submodule.Quotient.mk x = ↑(quotientInfEquivSupQuotient p p') 0 ↔ ↑x ∈ p'
Theorem: Finset.prod_le_pow_card
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: refine' (Multiset.prod_le_pow_card (s.val.map f) n _).trans _
state_before: ι : Type u_1
α : Type ?u.33275
β : Type ?u.33278
M : Type ?u.33281
N : Type u_2
G : Type ?u.33287
k : Type ?u.33290
R : Type ?u.33293
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f✝ g : ι → N
s✝ t s : Finset ι
f : ι → N
n : N
h : ∀ (x : ι), x ∈ s → f x ≤ n
⊢ Finset.prod s f ≤ n ^ card s

tactic: simpa using h
state_before: case refine'_1
ι : Type u_1
α : Type ?u.33275
β : Type ?u.33278
M : Type ?u.33281
N : Type u_2
G : Type ?u.33287
k : Type ?u.33290
R : Type ?u.33293
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f✝ g : ι → N
s✝ t s : Finset ι
f : ι → N
n : N
h : ∀ (x : ι), x ∈ s → f x ≤ n
⊢ ∀ (x : N), x ∈ Multiset.map f s.val → x ≤ n

tactic: simp
state_before: case refine'_2
ι : Type u_1
α : Type ?u.33275
β : Type ?u.33278
M : Type ?u.33281
N : Type u_2
G : Type ?u.33287
k : Type ?u.33290
R : Type ?u.33293
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f✝ g : ι → N
s✝ t s : Finset ι
f : ι → N
n : N
h : ∀ (x : ι), x ∈ s → f x ≤ n
⊢ n ^ ↑Multiset.card (Multiset.map f s.val) ≤ n ^ card s

tactic: rfl
state_before: case refine'_2
ι : Type u_1
α : Type ?u.33275
β : Type ?u.33278
M : Type ?u.33281
N : Type u_2
G : Type ?u.33287
k : Type ?u.33290
R : Type ?u.33293
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f✝ g : ι → N
s✝ t s : Finset ι
f : ι → N
n : N
h : ∀ (x : ι), x ∈ s → f x ≤ n
⊢ n ^ ↑Multiset.card s.val ≤ n ^ card s
Theorem: wittPolynomial_zMod_self
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

tactic: simp only [wittPolynomial_eq_sum_c_mul_x_pow]
state_before: p : ℕ
R : Type ?u.148919
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type ?u.148934
inst✝ : CommRing S
n : ℕ
⊢ W_ (ZMod (p ^ (n + 1))) (n + 1) = ↑(expand p) (W_ (ZMod (p ^ (n + 1))) n)

tactic: rw [sum_range_succ, ← Nat.cast_pow, CharP.cast_eq_zero (ZMod (p ^ (n + 1))) (p ^ (n + 1)), C_0,
  MulZeroClass.zero_mul, add_zero, AlgHom.map_sum, sum_congr rfl]
state_before: p : ℕ
R : Type ?u.148919
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type ?u.148934
inst✝ : CommRing S
n : ℕ
⊢ ∑ x in range (n + 1 + 1), ↑C (↑p ^ x) * X x ^ p ^ (n + 1 - x) =
    ↑(expand p) (∑ x in range (n + 1), ↑C (↑p ^ x) * X x ^ p ^ (n - x))

tactic: intro k hk
state_before: p : ℕ
R : Type ?u.148919
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type ?u.148934
inst✝ : CommRing S
n : ℕ
⊢ ∀ (x : ℕ), x ∈ range (n + 1) → ↑C (↑p ^ x) * X x ^ p ^ (n + 1 - x) = ↑(expand p) (↑C (↑p ^ x) * X x ^ p ^ (n - x))

tactic: rw [AlgHom.map_mul, AlgHom.map_pow, expand_X, algHom_C, ← pow_mul, ← pow_succ]
state_before: p : ℕ
R : Type ?u.148919
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type ?u.148934
inst✝ : CommRing S
n k : ℕ
hk : k ∈ range (n + 1)
⊢ ↑C (↑p ^ k) * X k ^ p ^ (n + 1 - k) = ↑(expand p) (↑C (↑p ^ k) * X k ^ p ^ (n - k))

tactic: congr
state_before: p : ℕ
R : Type ?u.148919
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type ?u.148934
inst✝ : CommRing S
n k : ℕ
hk : k ∈ range (n + 1)
⊢ ↑C (↑p ^ k) * X k ^ p ^ (n + 1 - k) = ↑C (↑p ^ k) * X k ^ p ^ (n - k + 1)

tactic: rw [mem_range] at hk
state_before: case e_a.e_a.e_a
p : ℕ
R : Type ?u.148919
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type ?u.148934
inst✝ : CommRing S
n k : ℕ
hk : k ∈ range (n + 1)
⊢ n + 1 - k = n - k + 1

tactic: rw [add_comm, add_tsub_assoc_of_le (Nat.lt_succ_iff.mp hk), ← add_comm]
state_before: case e_a.e_a.e_a
p : ℕ
R : Type ?u.148919
inst✝² : CommRing R
inst✝¹ : DecidableEq R
S : Type ?u.148934
inst✝ : CommRing S
n k : ℕ
hk : k < n + 1
⊢ n + 1 - k = n - k + 1
Theorem: IsUpperSet.interior
File: Mathlib/Topology/Algebra/Order/UpperLower.lean

tactic: rw [← isLowerSet_compl, ← closure_compl]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : HasUpperLowerClosure α
s : Set α
h : IsUpperSet s
⊢ IsUpperSet (interior s)

tactic: exact h.compl.closure
state_before: α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : HasUpperLowerClosure α
s : Set α
h : IsUpperSet s
⊢ IsLowerSet (closure (sᶜ))
Theorem: LowerAdjoint.mem_iff
File: Mathlib/Order/Closure.lean

tactic: simp_rw [← SetLike.mem_coe, ← Set.singleton_subset_iff, ← l.le_iff_subset]
state_before: α : Type u_2
ι : Sort ?u.24409
κ : ι → Sort ?u.24414
β : Type u_1
inst✝ : SetLike α β
l : LowerAdjoint SetLike.coe
s : Set β
x : β
⊢ x ∈ toFun l s ↔ ∀ (S : α), s ⊆ ↑S → x ∈ S

tactic: exact ⟨fun h S => h.trans, fun h => h _ le_rfl⟩
state_before: α : Type u_2
ι : Sort ?u.24409
κ : ι → Sort ?u.24414
β : Type u_1
inst✝ : SetLike α β
l : LowerAdjoint SetLike.coe
s : Set β
x : β
⊢ toFun l {x} ≤ toFun l s ↔ ∀ (S : α), toFun l s ≤ S → toFun l {x} ≤ S
Theorem: LaurentSeries.powerSeriesPart_zero
File: Mathlib/RingTheory/LaurentSeries.lean

tactic: ext
state_before: R : Type u
inst✝ : Semiring R
⊢ powerSeriesPart 0 = 0

tactic: simp
state_before: case h
R : Type u
inst✝ : Semiring R
n✝ : ℕ
⊢ ↑(PowerSeries.coeff R n✝) (powerSeriesPart 0) = ↑(PowerSeries.coeff R n✝) 0
Theorem: one_le_bit1
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rw [bit1, le_add_iff_nonneg_left, bit0, ← two_mul, zero_le_mul_left (zero_lt_two : 0 < (2 : α))]
state_before: α : Type u
β : Type ?u.130379
inst✝ : LinearOrderedSemiring α
a b c d : α
⊢ 1 ≤ bit1 a ↔ 0 ≤ a
Theorem: ForInStep.done_bindList
File: Std/Control/ForInStep/Lemmas.lean

tactic: cases l <;> simp
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
f : α → β → m (ForInStep β)
a : β
l : List α
⊢ bindList f l (done a) = pure (done a)
Theorem: Metric.preimage_mul_right_ball
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: rw [div_eq_mul_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b / a) r

tactic: exact preimage_smul_ball (MulOpposite.op a) b r
state_before: M : Type u
G : Type v
X : Type w
inst✝⁵ : PseudoMetricSpace X
inst✝⁴ : Group G
inst✝³ : MulAction G X
inst✝² : IsometricSMul G X
inst✝¹ : PseudoMetricSpace G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
r : ℝ
⊢ (fun x => x * a) ⁻¹' ball b r = ball (b * a⁻¹) r
Theorem: GroupCat.SurjectiveOfEpiAuxs.comp_eq
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: ext a
state_before: A B : GroupCat
f : A ⟶ B
⊢ (f ≫
      let_fun this := g;
      this) =
    f ≫
      let_fun this := h;
      this

tactic: change g (f a) = h (f a)
state_before: case w
A B : GroupCat
f : A ⟶ B
a : ↑A
⊢ ↑(f ≫
          let_fun this := g;
          this)
      a =
    ↑(f ≫
          let_fun this := h;
          this)
      a

tactic: have : f a ∈ { b | h b = g b } := by
  rw [←agree]
  use a
state_before: case w
A B : GroupCat
f : A ⟶ B
a : ↑A
⊢ ↑g (↑f a) = ↑h (↑f a)

tactic: rw [this]
state_before: case w
A B : GroupCat
f : A ⟶ B
a : ↑A
this : ↑f a ∈ {b | ↑h b = ↑g b}
⊢ ↑g (↑f a) = ↑h (↑f a)

tactic: rw [←agree]
state_before: A B : GroupCat
f : A ⟶ B
a : ↑A
⊢ ↑f a ∈ {b | ↑h b = ↑g b}

tactic: use a
state_before: A B : GroupCat
f : A ⟶ B
a : ↑A
⊢ ↑f a ∈ (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier
Theorem: WithSeminorms.tendsto_nhds
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rw [hp.tendsto_nhds' u y₀]
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.423602
𝕝 : Type ?u.423605
𝕝₂ : Type ?u.423608
E : Type u_2
F : Type u_4
G : Type ?u.423617
ι : Type u_3
ι' : Type ?u.423623
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
u : F → E
f : Filter F
y₀ : E
⊢ Filter.Tendsto u f (𝓝 y₀) ↔ ∀ (i : ι) (ε : ℝ), 0 < ε → ∀ᶠ (x : F) in f, ↑(p i) (u x - y₀) < ε

tactic: exact
  ⟨fun h i => by simpa only [Finset.sup_singleton] using h {i}, fun h s ε hε =>
    (s.eventually_all.2 fun i _ => h i ε hε).mono fun _ => finset_sup_apply_lt hε⟩
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.423602
𝕝 : Type ?u.423605
𝕝₂ : Type ?u.423608
E : Type u_2
F : Type u_4
G : Type ?u.423617
ι : Type u_3
ι' : Type ?u.423623
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
u : F → E
f : Filter F
y₀ : E
⊢ (∀ (s : Finset ι) (ε : ℝ), 0 < ε → ∀ᶠ (x : F) in f, ↑(Finset.sup s p) (u x - y₀) < ε) ↔
    ∀ (i : ι) (ε : ℝ), 0 < ε → ∀ᶠ (x : F) in f, ↑(p i) (u x - y₀) < ε

tactic: simpa only [Finset.sup_singleton] using h {i}
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.423602
𝕝 : Type ?u.423605
𝕝₂ : Type ?u.423608
E : Type u_2
F : Type u_4
G : Type ?u.423617
ι : Type u_3
ι' : Type ?u.423623
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
u : F → E
f : Filter F
y₀ : E
h : ∀ (s : Finset ι) (ε : ℝ), 0 < ε → ∀ᶠ (x : F) in f, ↑(Finset.sup s p) (u x - y₀) < ε
i : ι
⊢ ∀ (ε : ℝ), 0 < ε → ∀ᶠ (x : F) in f, ↑(p i) (u x - y₀) < ε
Theorem: CategoryTheory.Limits.PreservesPushout.inr_iso_inv
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean

tactic: simp [PreservesPushout.iso, Iso.comp_inv_eq]
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
G : C ⥤ D
W X Y Z : C
h : X ⟶ Z
k : Y ⟶ Z
f : W ⟶ X
g : W ⟶ Y
comm : f ≫ h = g ≫ k
inst✝² : PreservesColimit (span f g) G
inst✝¹ : HasPushout f g
inst✝ : HasPushout (G.map f) (G.map g)
⊢ G.map pushout.inr ≫ (iso G f g).inv = pushout.inr
Theorem: FirstOrder.Language.model_nonemptyTheory_iff
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp only [nonemptyTheory, Theory.model_iff, Set.mem_singleton_iff, forall_eq,
  Sentence.realize_cardGe, Nat.cast_one, one_le_iff_ne_zero, mk_ne_zero_iff]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.819644
P : Type ?u.819647
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
⊢ M ⊨ nonemptyTheory L ↔ Nonempty M
Theorem: TypeVec.const_iff_true
File: Mathlib/Data/TypeVec.lean

tactic: induction i
state_before: n : ℕ
α : TypeVec n
i : Fin2 n
x : α i
p : Prop
⊢ ofRepeat (TypeVec.const p α i x) ↔ p

tactic: case fz       => rfl
state_before: case fz
n : ℕ
p : Prop
n✝ : ℕ
α : TypeVec (succ n✝)
x : α Fin2.fz
⊢ ofRepeat (TypeVec.const p α Fin2.fz x) ↔ p

case fs
n : ℕ
p : Prop
n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α : TypeVec n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p
α : TypeVec (succ n✝)
x : α (Fin2.fs a✝)
⊢ ofRepeat (TypeVec.const p α (Fin2.fs a✝) x) ↔ p

tactic: case fs _ ih  => erw [TypeVec.const, @ih (drop α) x]
state_before: case fs
n : ℕ
p : Prop
n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α : TypeVec n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p
α : TypeVec (succ n✝)
x : α (Fin2.fs a✝)
⊢ ofRepeat (TypeVec.const p α (Fin2.fs a✝) x) ↔ p

tactic: rfl
state_before: n : ℕ
p : Prop
n✝ : ℕ
α : TypeVec (succ n✝)
x : α Fin2.fz
⊢ ofRepeat (TypeVec.const p α Fin2.fz x) ↔ p

tactic: erw [TypeVec.const, @ih (drop α) x]
state_before: n : ℕ
p : Prop
n✝ : ℕ
a✝ : Fin2 n✝
ih : ∀ {α : TypeVec n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p
α : TypeVec (succ n✝)
x : α (Fin2.fs a✝)
⊢ ofRepeat (TypeVec.const p α (Fin2.fs a✝) x) ↔ p
Theorem: Vector.eq_cons_iff
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [h.1, h.2]
state_before: n : ℕ
α : Type u_1
a : α
v : Vector α (Nat.succ n)
v' : Vector α n
h : head v = a ∧ tail v = v'
⊢ head v ::ᵥ tail v = a ::ᵥ v'
Theorem: Set.mem_univ_pi
File: Mathlib/Data/Set/Prod.lean

tactic: simp
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.112247
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
f : (i : ι) → α i
⊢ f ∈ pi univ t ↔ ∀ (i : ι), f i ∈ t i
Theorem: Int.mul_div_cancel_of_mod_eq_zero
File: Std/Data/Int/DivMod.lean

tactic: have := mod_add_div a b
state_before: a b : Int
H : mod a b = 0
⊢ b * div a b = a

tactic: rwa [H, Int.zero_add] at this
state_before: a b : Int
H : mod a b = 0
this : mod a b + b * div a b = a
⊢ b * div a b = a
Theorem: ite_eq_iff
File: Mathlib/Logic/Basic.lean

tactic: simp only
state_before: α : Sort u_1
β : Sort ?u.33143
σ : α → Sort ?u.33139
f : α → β
P Q : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ ((∃ h, (fun x => a) h = c) ∨ ∃ h, (fun x => b) h = c) ↔ P ∧ a = c ∨ ¬P ∧ b = c

tactic: rw [exists_prop, exists_prop]
state_before: α : Sort u_1
β : Sort ?u.33143
σ : α → Sort ?u.33139
f : α → β
P Q : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ ((∃ h, a = c) ∨ ∃ h, b = c) ↔ P ∧ a = c ∨ ¬P ∧ b = c
Theorem: Units.eq_mul_inv_iff_mul_eq
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [h, inv_mul_cancel_right]
state_before: α : Type u
inst✝ : Monoid α
a✝ b✝ c u : αˣ
a b : α
h : a = b * ↑c⁻¹
⊢ a * ↑c = b

tactic: rw [← h, mul_inv_cancel_right]
state_before: α : Type u
inst✝ : Monoid α
a✝ b✝ c u : αˣ
a b : α
h : a * ↑c = b
⊢ a = b * ↑c⁻¹
Theorem: CategoryTheory.Free.lift_map_single
File: Mathlib/Algebra/Category/ModuleCat/Adjunctions.lean

tactic: simp
state_before: R : Type u_1
inst✝⁴ : CommRing R
C : Type u
inst✝³ : Category C
D : Type u
inst✝² : Category D
inst✝¹ : Preadditive D
inst✝ : Linear R D
F : C ⥤ D
X Y : C
f : X ⟶ Y
r : R
⊢ (lift R F).map (single f r) = r • F.map f
Theorem: Fin.prod_univ_six
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [prod_univ_castSucc, prod_univ_five]
state_before: α : Type ?u.25201
β : Type u_1
inst✝ : CommMonoid β
f : Fin 6 → β
⊢ ∏ i : Fin 6, f i = f 0 * f 1 * f 2 * f 3 * f 4 * f 5

tactic: rfl
state_before: α : Type ?u.25201
β : Type u_1
inst✝ : CommMonoid β
f : Fin 6 → β
⊢ f (↑castSucc 0) * f (↑castSucc 1) * f (↑castSucc 2) * f (↑castSucc 3) * f (↑castSucc 4) * f (last 5) =
    f 0 * f 1 * f 2 * f 3 * f 4 * f 5
Theorem: AddLECancellable.add_tsub_assoc_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: conv_lhs => rw [← add_tsub_cancel_of_le h, add_comm c, ← add_assoc, hc.add_tsub_cancel_right]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a✝ b c d : α
hc : AddLECancellable c
h : c ≤ b
a : α
⊢ a + b - c = a + (b - c)
Theorem: Int.sign_eq_sign
File: Mathlib/Data/Sign.lean

tactic: obtain (n | _) | _ := n <;> simp [sign, Int.sign_neg, negSucc_lt_zero]
state_before: α : Type ?u.128001
n : ℤ
⊢ sign n = ↑(↑SignType.sign n)
Theorem: CategoryTheory.Functor.pUnit_ext'
File: Mathlib/CategoryTheory/PUnit.lean

tactic: simp only [eq_iff_true_of_subsingleton]
state_before: C : Type u
inst✝ : Category C
F G : C ⥤ Discrete PUnit
X : C
⊢ F.obj X = G.obj X
Theorem: zpow_eq_mod_orderOf
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [← Int.emod_add_ediv i (orderOf x)]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Group G
inst✝ : AddGroup A
i : ℤ
⊢ x ^ i = ?m.909316

tactic: simp [zpow_add, zpow_mul, pow_orderOf_eq_one]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Group G
inst✝ : AddGroup A
i : ℤ
⊢ x ^ (i % ↑(orderOf x) + ↑(orderOf x) * (i / ↑(orderOf x))) = x ^ (i % ↑(orderOf x))
Theorem: MeasureTheory.SignedMeasure.rnDeriv_smul
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: refine'
  Integrable.ae_eq_of_withDensityᵥ_eq (integrable_rnDeriv _ _)
    ((integrable_rnDeriv _ _).smul r) _
state_before: α : Type u_1
β : Type ?u.647949
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
⊢ rnDeriv (r • s) μ =ᶠ[ae μ] r • rnDeriv s μ

tactic: change _ = μ.withDensityᵥ ((r : ℝ) • s.rnDeriv μ)
state_before: α : Type u_1
β : Type ?u.647949
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
⊢ withDensityᵥ μ (rnDeriv (r • s) μ) = withDensityᵥ μ (r • rnDeriv s μ)

tactic: rw [withDensityᵥ_smul (rnDeriv s μ) (r : ℝ), ← add_right_inj ((r • s).singularPart μ),
  singularPart_add_withDensity_rnDeriv_eq, singularPart_smul]
state_before: α : Type u_1
β : Type ?u.647949
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
⊢ withDensityᵥ μ (rnDeriv (r • s) μ) = withDensityᵥ μ (r • rnDeriv s μ)

tactic: change _ = _ + r • _
state_before: α : Type u_1
β : Type ?u.647949
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
⊢ r • s = r • singularPart s μ + r • withDensityᵥ μ (rnDeriv s μ)

tactic: rw [← smul_add, singularPart_add_withDensity_rnDeriv_eq]
state_before: α : Type u_1
β : Type ?u.647949
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t s : SignedMeasure α
μ : Measure α
inst✝ : HaveLebesgueDecomposition s μ
r : ℝ
⊢ r • s = r • singularPart s μ + r • withDensityᵥ μ (rnDeriv s μ)
Theorem: Real.cos_two_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [cos_two_mul]
state_before: x y : ℝ
⊢ ↑(cos (2 * x)) = ↑(2 * cos x ^ 2 - 1)
Theorem: List.prod_isUnit
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: simp
state_before: ι : Type ?u.48568
α : Type ?u.48571
M : Type u_1
N : Type ?u.48577
P : Type ?u.48580
M₀ : Type ?u.48583
G : Type ?u.48586
R : Type ?u.48589
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
x✝ : ∀ (m : M), m ∈ [] → IsUnit m
⊢ IsUnit (prod [])

tactic: simp only [List.prod_cons]
state_before: ι : Type ?u.48568
α : Type ?u.48571
M : Type u_1
N : Type ?u.48577
P : Type ?u.48580
M₀ : Type ?u.48583
G : Type ?u.48586
R : Type ?u.48589
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a h : M
t : List M
u : ∀ (m : M), m ∈ h :: t → IsUnit m
⊢ IsUnit (prod (h :: t))

tactic: exact IsUnit.mul (u h (mem_cons_self h t)) (prod_isUnit fun m mt => u m (mem_cons_of_mem h mt))
state_before: ι : Type ?u.48568
α : Type ?u.48571
M : Type u_1
N : Type ?u.48577
P : Type ?u.48580
M₀ : Type ?u.48583
G : Type ?u.48586
R : Type ?u.48589
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a h : M
t : List M
u : ∀ (m : M), m ∈ h :: t → IsUnit m
⊢ IsUnit (h * prod t)
Theorem: HilbertBasis.hasSum_repr
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: simpa using b.hasSum_repr_symm (b.repr x)
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.790578
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
x : E
⊢ HasSum (fun i => ↑(↑b.repr x) i • (fun i => ↑(LinearIsometryEquiv.symm b.repr) (lp.single 2 i 1)) i) x
Theorem: Multiset.prod_add
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: simp
state_before: ι : Type ?u.13316
α : Type u_1
β : Type ?u.13322
γ : Type ?u.13325
inst✝ : CommMonoid α
s✝ t✝ : Multiset α
a : α
m : Multiset ι
f g : ι → α
s t : Multiset α
l₁ l₂ : List α
⊢ prod (Quotient.mk (List.isSetoid α) l₁ + Quotient.mk (List.isSetoid α) l₂) =
    prod (Quotient.mk (List.isSetoid α) l₁) * prod (Quotient.mk (List.isSetoid α) l₂)
Theorem: IsROrC.sub_conj
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [re_add_im, ← conj_eq_re_sub_im]
state_before: K : Type u_1
E : Type ?u.2979461
inst✝ : IsROrC K
z : K
⊢ z - ↑(starRingEnd K) z = ↑(↑re z) + ↑(↑im z) * I - (↑(↑re z) - ↑(↑im z) * I)

tactic: rw [add_sub_sub_cancel, ← two_mul, mul_assoc]
state_before: K : Type u_1
E : Type ?u.2979461
inst✝ : IsROrC K
z : K
⊢ ↑(↑re z) + ↑(↑im z) * I - (↑(↑re z) - ↑(↑im z) * I) = 2 * ↑(↑im z) * I