tasksource/leandojo huggingface dataset:
Theorem: Ring.mul_inverse_rev'
File: Mathlib/Algebra/GroupWithZero/Commute.lean

tactic: by_cases hab : IsUnit (a * b)
state_before: α : Type ?u.47
M₀ : Type u_1
G₀ : Type ?u.53
M₀' : Type ?u.56
G₀' : Type ?u.59
F : Type ?u.62
F' : Type ?u.65
inst✝ : MonoidWithZero M₀
a b : M₀
h : Commute a b
⊢ inverse (a * b) = inverse b * inverse a

tactic: obtain ha | hb := not_and_or.mp (mt h.isUnit_mul_iff.mpr hab)
state_before: case neg
α : Type ?u.47
M₀ : Type u_1
G₀ : Type ?u.53
M₀' : Type ?u.56
G₀' : Type ?u.59
F : Type ?u.62
F' : Type ?u.65
inst✝ : MonoidWithZero M₀
a b : M₀
h : Commute a b
hab : ¬IsUnit (a * b)
⊢ inverse (a * b) = inverse b * inverse a

tactic: obtain ⟨⟨a, rfl⟩, b, rfl⟩ := h.isUnit_mul_iff.mp hab
state_before: case pos
α : Type ?u.47
M₀ : Type u_1
G₀ : Type ?u.53
M₀' : Type ?u.56
G₀' : Type ?u.59
F : Type ?u.62
F' : Type ?u.65
inst✝ : MonoidWithZero M₀
a b : M₀
h : Commute a b
hab : IsUnit (a * b)
⊢ inverse (a * b) = inverse b * inverse a

tactic: rw [← Units.val_mul, inverse_unit, inverse_unit, inverse_unit, ← Units.val_mul, mul_inv_rev]
state_before: case pos.intro.intro.intro
α : Type ?u.47
M₀ : Type u_1
G₀ : Type ?u.53
M₀' : Type ?u.56
G₀' : Type ?u.59
F : Type ?u.62
F' : Type ?u.65
inst✝ : MonoidWithZero M₀
a b : M₀ˣ
h : Commute ↑a ↑b
hab : IsUnit (↑a * ↑b)
⊢ inverse (↑a * ↑b) = inverse ↑b * inverse ↑a

tactic: rw [inverse_non_unit _ hab, inverse_non_unit _ ha, mul_zero]
state_before: case neg.inl
α : Type ?u.47
M₀ : Type u_1
G₀ : Type ?u.53
M₀' : Type ?u.56
G₀' : Type ?u.59
F : Type ?u.62
F' : Type ?u.65
inst✝ : MonoidWithZero M₀
a b : M₀
h : Commute a b
hab : ¬IsUnit (a * b)
ha : ¬IsUnit a
⊢ inverse (a * b) = inverse b * inverse a

tactic: rw [inverse_non_unit _ hab, inverse_non_unit _ hb, zero_mul]
state_before: case neg.inr
α : Type ?u.47
M₀ : Type u_1
G₀ : Type ?u.53
M₀' : Type ?u.56
G₀' : Type ?u.59
F : Type ?u.62
F' : Type ?u.65
inst✝ : MonoidWithZero M₀
a b : M₀
h : Commute a b
hab : ¬IsUnit (a * b)
hb : ¬IsUnit b
⊢ inverse (a * b) = inverse b * inverse a
Theorem: Polynomial.expand_one
File: Mathlib/Data/Polynomial/Expand.lean

tactic: rw [expand_C]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
r : R
⊢ ↑(expand R 1) (↑C r) = ↑C r

tactic: rw [AlgHom.map_add, ihf, ihg]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f✝ f g : R[X]
ihf : ↑(expand R 1) f = f
ihg : ↑(expand R 1) g = g
⊢ ↑(expand R 1) (f + g) = f + g

tactic: rw [AlgHom.map_mul, expand_C, AlgHom.map_pow, expand_X, pow_one]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
n : ℕ
r : R
x✝ : ↑(expand R 1) (↑C r * X ^ n) = ↑C r * X ^ n
⊢ ↑(expand R 1) (↑C r * X ^ (n + 1)) = ↑C r * X ^ (n + 1)
Theorem: toIocMod_sub_zsmul'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp_rw [sub_eq_add_neg, ← neg_smul, toIocMod_add_zsmul']
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocMod hp (a - m • p) b = toIocMod hp a b - m • p
Theorem: Set.Ico_disjoint_Ico
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: simp_rw [Set.disjoint_iff_inter_eq_empty, Ico_inter_Ico, Ico_eq_empty_iff, inf_eq_min, sup_eq_max,
  not_lt]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ : α
⊢ Disjoint (Ico a₁ a₂) (Ico b₁ b₂) ↔ min a₂ b₂ ≤ max a₁ b₁
Theorem: ContinuousLinearMap.adjointAux_inner_right
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: rw [← inner_conj_symm, adjointAux_inner_left, inner_conj_symm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.269290
inst✝⁸ : IsROrC 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace G
A : E →L[𝕜] F
x : E
y : F
⊢ inner x (↑(↑adjointAux A) y) = inner (↑A x) y
Theorem: Asymptotics.IsBigO.sub
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa only [sub_eq_add_neg] using h₁.add h₂.neg_left
state_before: α : Type u_1
β : Type ?u.226071
E : Type ?u.226074
F : Type u_3
G : Type ?u.226080
E' : Type u_2
F' : Type ?u.226086
G' : Type ?u.226089
E'' : Type ?u.226092
F'' : Type ?u.226095
G'' : Type ?u.226098
R : Type ?u.226101
R' : Type ?u.226104
𝕜 : Type ?u.226107
𝕜' : Type ?u.226110
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E'
g₁ g₂ : α → F'
h₁ : f₁ =O[l] g
h₂ : f₂ =O[l] g
⊢ (fun x => f₁ x - f₂ x) =O[l] g
Theorem: SimpleGraph.cliqueFree_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: rw [← not_iff_not, not_cliqueFree_iff, not_isEmpty_iff]
state_before: α : Type u_1
G H : SimpleGraph α
m n✝ : ℕ
s : Finset α
n : ℕ
⊢ CliqueFree G n ↔ IsEmpty (⊤ ↪g G)
Theorem: one_sub_gold
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: linarith [gold_add_goldConj]
state_before: ⊢ 1 - ψ = φ
Theorem: Real.coe_fib_eq
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [← Function.funext_iff, Real.coe_fib_eq']
state_before: ⊢ ∀ (n : ℕ), ↑(Nat.fib n) = (φ ^ n - ψ ^ n) / sqrt 5
Theorem: LatticeOrderedCommGroup.sup_eq_mul_pos_div
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [mul_one b, div_eq_mul_inv, mul_comm a, mul_inv_cancel_left]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a ⊔ b = b * (a / b) ⊔ b * 1

tactic: rw [← mul_sup (a / b) 1 b]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ b * (a / b) ⊔ b * 1 = b * (a / b ⊔ 1)
Theorem: Set.pi_eq_empty_iff
File: Mathlib/Data/Set/Prod.lean

tactic: rw [← not_nonempty_iff_eq_empty, pi_nonempty_iff]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.122847
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ pi s t = ∅ ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅

tactic: push_neg
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.122847
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ (¬∀ (i : ι), ∃ x, i ∈ s → x ∈ t i) ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅

tactic: refine' exists_congr fun i => _
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.122847
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ (∃ i, ∀ (x : α i), i ∈ s ∧ ¬x ∈ t i) ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅

tactic: cases isEmpty_or_nonempty (α i) <;> simp [*, forall_and, eq_empty_iff_forall_not_mem]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.122847
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i✝ i : ι
⊢ (∀ (x : α i), i ∈ s ∧ ¬x ∈ t i) ↔ IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅
Theorem: Ideal.sup_prod_eq_top
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp_rw [one_eq_top, sup_top_eq]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J✝ K L : Ideal R
s : Finset ι
J : ι → Ideal R
h : ∀ (i : ι), i ∈ s → I ⊔ J i = ⊤
⊢ (fun J => I ⊔ J = ⊤) 1
Theorem: List.map_foldl_erase
File: Mathlib/Data/List/Basic.lean

tactic: induction l₂ generalizing l₁ <;> [rfl; simp only [foldl_cons, map_erase finj, *]]
state_before: ι : Type ?u.427557
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
finj : Injective f
l₁ l₂ : List α
⊢ map f (foldl List.erase l₁ l₂) = foldl (fun l a => List.erase l (f a)) (map f l₁) l₂
Theorem: Filter.mem_inf_principal'
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [← le_principal_iff, (isCompl_principal s).le_left_iff, disjoint_assoc, inf_principal,
  ← (isCompl_principal (t ∩ sᶜ)).le_right_iff, compl_inter, compl_compl]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.117799
ι : Sort x
f✝ g : Filter α
s✝ t✝ : Set α
f : Filter α
s t : Set α
⊢ s ∈ f ⊓ 𝓟 t ↔ tᶜ ∪ s ∈ f
Theorem: EqualCharZero.of_not_mixedCharZero
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: intro I hI_ne_top
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
h : ∀ (p : ℕ), p > 0 → ¬MixedCharZero R p
⊢ ∀ (I : Ideal R), I ≠ ⊤ → CharZero (R ⧸ I)

tactic: suffices h_charP : CharP (R ⧸ I) 0
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
h : ∀ (p : ℕ), p > 0 → ¬MixedCharZero R p
I : Ideal R
hI_ne_top : I ≠ ⊤
⊢ CharZero (R ⧸ I)

tactic: cases CharP.exists (R ⧸ I) with
| intro p hp =>
  cases p with
  | zero => exact hp
  | succ p =>
    have h_mixed : MixedCharZero R p.succ := ⟨⟨I, ⟨hI_ne_top, hp⟩⟩⟩
    exact absurd h_mixed (h p.succ p.succ_pos)
state_before: case h_charP
R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
h : ∀ (p : ℕ), p > 0 → ¬MixedCharZero R p
I : Ideal R
hI_ne_top : I ≠ ⊤
⊢ CharP (R ⧸ I) 0

tactic: apply CharP.charP_to_charZero
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
h : ∀ (p : ℕ), p > 0 → ¬MixedCharZero R p
I : Ideal R
hI_ne_top : I ≠ ⊤
h_charP : CharP (R ⧸ I) 0
⊢ CharZero (R ⧸ I)

tactic: cases p with
| zero => exact hp
| succ p =>
  have h_mixed : MixedCharZero R p.succ := ⟨⟨I, ⟨hI_ne_top, hp⟩⟩⟩
  exact absurd h_mixed (h p.succ p.succ_pos)
state_before: case h_charP.intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
h : ∀ (p : ℕ), p > 0 → ¬MixedCharZero R p
I : Ideal R
hI_ne_top : I ≠ ⊤
p : ℕ
hp : CharP (R ⧸ I) p
⊢ CharP (R ⧸ I) 0

tactic: exact hp
state_before: case h_charP.intro.zero
R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
h : ∀ (p : ℕ), p > 0 → ¬MixedCharZero R p
I : Ideal R
hI_ne_top : I ≠ ⊤
hp : CharP (R ⧸ I) Nat.zero
⊢ CharP (R ⧸ I) 0

tactic: have h_mixed : MixedCharZero R p.succ := ⟨⟨I, ⟨hI_ne_top, hp⟩⟩⟩
state_before: case h_charP.intro.succ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
h : ∀ (p : ℕ), p > 0 → ¬MixedCharZero R p
I : Ideal R
hI_ne_top : I ≠ ⊤
p : ℕ
hp : CharP (R ⧸ I) (Nat.succ p)
⊢ CharP (R ⧸ I) 0

tactic: exact absurd h_mixed (h p.succ p.succ_pos)
state_before: case h_charP.intro.succ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
h : ∀ (p : ℕ), p > 0 → ¬MixedCharZero R p
I : Ideal R
hI_ne_top : I ≠ ⊤
p : ℕ
hp : CharP (R ⧸ I) (Nat.succ p)
h_mixed : MixedCharZero R (Nat.succ p)
⊢ CharP (R ⧸ I) 0
Theorem: Real.le_toNNReal_iff_coe_le'
File: Mathlib/Data/Real/NNReal.lean

tactic: simp only [(hp.trans_le r.coe_nonneg).not_le, toNNReal_eq_zero.2 hp.le, hr.not_le]
state_before: r : ℝ≥0
p : ℝ
hr : 0 < r
hp : p < 0
⊢ r ≤ toNNReal p ↔ ↑r ≤ p
Theorem: Bitvec.toFin_ofFin
File: Mathlib/Data/Bitvec/Lemmas.lean

tactic: simp [toFin_val, ofFin, toNat_ofNat, Nat.mod_eq_of_lt, i.is_lt]
state_before: n : ℕ
i : Fin (2 ^ n)
⊢ ↑(toFin (ofFin i)) = ↑i
Theorem: stronglyMeasurable_deriv
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: borelize F
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type ?u.404351
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type u_2
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
f✝ : E → F
K : Set (E →L[𝕜] F)
inst✝⁵ : MeasurableSpace E
inst✝⁴ : OpensMeasurableSpace E
inst✝³ : CompleteSpace F
inst✝² : MeasurableSpace 𝕜
inst✝¹ : OpensMeasurableSpace 𝕜
inst✝ : SecondCountableTopology F
f : 𝕜 → F
⊢ StronglyMeasurable (deriv f)

tactic: exact (measurable_deriv f).stronglyMeasurable
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type ?u.404351
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type u_2
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
f✝ : E → F
K : Set (E →L[𝕜] F)
inst✝⁵ : MeasurableSpace E
inst✝⁴ : OpensMeasurableSpace E
inst✝³ : CompleteSpace F
inst✝² : MeasurableSpace 𝕜
inst✝¹ : OpensMeasurableSpace 𝕜
inst✝ : SecondCountableTopology F
f : 𝕜 → F
this✝¹ : MeasurableSpace F := borel F
this✝ : BorelSpace F
⊢ StronglyMeasurable (deriv f)
Theorem: StrictConvexSpace.ofNormAddNeTwo
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: refine'
  StrictConvexSpace.ofNormComboNeOne fun x y hx hy hne =>
    ⟨1 / 2, 1 / 2, one_half_pos.le, one_half_pos.le, add_halves _, _⟩
state_before: 𝕜 : Type ?u.32392
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2
⊢ StrictConvexSpace ℝ E

tactic: rw [← smul_add, norm_smul, Real.norm_of_nonneg one_half_pos.le, one_div, ← div_eq_inv_mul, Ne.def,
  div_eq_one_iff_eq (two_ne_zero' ℝ)]
state_before: 𝕜 : Type ?u.32392
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2
x y : E
hx : ‖x‖ = 1
hy : ‖y‖ = 1
hne : x ≠ y
⊢ ‖(1 / 2) • x + (1 / 2) • y‖ ≠ 1

tactic: exact h hx hy hne
state_before: 𝕜 : Type ?u.32392
E : Type u_1
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2
x y : E
hx : ‖x‖ = 1
hy : ‖y‖ = 1
hne : x ≠ y
⊢ ¬‖x + y‖ = 2
Theorem: Array.ext'
File: src/lean/Init/Data/Array/Basic.lean

tactic: cases as
state_before: α : Type u_1
as bs : Array α
h : as.data = bs.data
⊢ as = bs

tactic: cases bs
state_before: case mk
α : Type u_1
bs : Array α
data✝ : List α
h : { data := data✝ }.data = bs.data
⊢ { data := data✝ } = bs

tactic: simp at h
state_before: case mk.mk
α : Type u_1
data✝¹ data✝ : List α
h : { data := data✝¹ }.data = { data := data✝ }.data
⊢ { data := data✝¹ } = { data := data✝ }

tactic: rw [h]
state_before: case mk.mk
α : Type u_1
data✝¹ data✝ : List α
h : data✝¹ = data✝
⊢ { data := data✝¹ } = { data := data✝ }
Theorem: padicNorm.div
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [hr]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hr : r = 0
⊢ padicNorm p (q / r) = padicNorm p q / padicNorm p r

tactic: rw [← padicNorm.mul, div_mul_cancel _ hr]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hr : ¬r = 0
⊢ padicNorm p (q / r) * padicNorm p r = padicNorm p q
Theorem: intervalIntegral.integral_comp_mul_sub
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa only [sub_eq_add_neg] using integral_comp_mul_add f hc (-d)
state_before: ι : Type ?u.14913175
𝕜 : Type ?u.14913178
E : Type u_1
F : Type ?u.14913184
A : Type ?u.14913187
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d✝ : ℝ
f : ℝ → E
hc : c ≠ 0
d : ℝ
⊢ (∫ (x : ℝ) in a..b, f (c * x - d)) = c⁻¹ • ∫ (x : ℝ) in c * a - d..c * b - d, f x
Theorem: Unitization.algHom_ext'
File: Mathlib/Algebra/Algebra/Unitization.lean

tactic: simp [AlgHom.commutes]
state_before: S : Type ?u.440894
R : Type u_1
A : Type u_2
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type ?u.444063
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type u_3
inst✝¹ : Semiring C
inst✝ : Algebra R C
φ ψ : Unitization R A →ₐ[R] C
h : NonUnitalAlgHom.comp (↑φ) (inrNonUnitalAlgHom R A) = NonUnitalAlgHom.comp (↑ψ) (inrNonUnitalAlgHom R A)
⊢ ∀ (r : R), ↑φ (↑(algebraMap R (Unitization R A)) r) = ↑ψ (↑(algebraMap R (Unitization R A)) r)
Theorem: Polynomial.monic_normalize
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [Ne.def, ← leadingCoeff_eq_zero, ← Ne.def, ← isUnit_iff_ne_zero] at hp0
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp0 : p ≠ 0
⊢ Monic (↑normalize p)

tactic: rw [Monic, leadingCoeff_normalize, normalize_eq_one]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp0 : IsUnit (leadingCoeff p)
⊢ Monic (↑normalize p)

tactic: apply hp0
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp0 : IsUnit (leadingCoeff p)
⊢ IsUnit (leadingCoeff p)
Theorem: DirectSum.IsInternal.collectedBasis_mem
File: Mathlib/Algebra/DirectSum/Module.lean

tactic: simp
state_before: R : Type u
inst✝² : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
A : ι → Submodule R M
h : IsInternal A
α : ι → Type u_2
v : (i : ι) → Basis (α i) R { x // x ∈ A i }
a : (i : ι) × α i
⊢ ↑(collectedBasis h v) a ∈ A a.fst
Theorem: LinearMap.isSkewAdjoint_iff_neg_self_adjoint
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: simp
state_before: R : Type u_1
R₁ : Type ?u.439810
R₂ : Type ?u.439813
R₃ : Type ?u.439816
M : Type u_2
M₁ : Type ?u.439822
M₂ : Type ?u.439825
Mₗ₁ : Type ?u.439828
Mₗ₁' : Type ?u.439831
Mₗ₂ : Type ?u.439834
Mₗ₂' : Type ?u.439837
K : Type ?u.439840
K₁ : Type ?u.439843
K₂ : Type ?u.439846
V : Type ?u.439849
V₁ : Type ?u.439852
V₂ : Type ?u.439855
n : Type ?u.439858
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M₁
inst✝ : Module R M₁
B F : M →ₗ[R] M →ₗ[R] R
f : Module.End R M
⊢ (∀ (x y : M), ↑(↑B (↑f x)) y = ↑(↑B x) (↑(-f) y)) ↔ ∀ (x y : M), ↑(↑B (↑f x)) y = ↑(↑(-B) x) (↑f y)
Theorem: LocalizedModule.mul_by_divBy
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: intro ⟨m, t⟩
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
⊢ ∀ (a : M × { x // x ∈ S }),
    ↑(↑(algebraMap R (Module.End R (LocalizedModule S M))) ↑s) (↑(divBy s) (Quotient.mk (r.setoid S M) a)) =
      Quotient.mk (r.setoid S M) a

tactic: simp only [LocalizedModule.liftOn_mk, divBy_apply, Module.algebraMap_end_apply, smul'_mk]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
m : M
t : { x // x ∈ S }
⊢ ↑(↑(algebraMap R (Module.End R (LocalizedModule S M))) ↑s) (↑(divBy s) (Quotient.mk (r.setoid S M) (m, t))) =
    Quotient.mk (r.setoid S M) (m, t)

tactic: erw [LocalizedModule.liftOn_mk, smul'_mk]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
m : M
t : { x // x ∈ S }
⊢ ↑s •
      liftOn (Quotient.mk (r.setoid S M) (m, t)) (fun p => mk p.fst (s * p.snd))
        (_ :
          ∀ (x x_1 : M × { x // x ∈ S }),
            x ≈ x_1 → (fun p => mk p.fst (s * p.snd)) x = (fun p => mk p.fst (s * p.snd)) x_1) =
    Quotient.mk (r.setoid S M) (m, t)

tactic: change mk (s • m) (s * t) = mk m t
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
m : M
t : { x // x ∈ S }
⊢ mk (↑s • (m, t).fst) (s * (m, t).snd) = Quotient.mk (r.setoid S M) (m, t)

tactic: rw [mk_cancel_common_left s t]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
m : M
t : { x // x ∈ S }
⊢ mk (s • m) (s * t) = mk m t
Theorem: IsUnit.div_left_inj
File: Mathlib/Algebra/Hom/Units.lean

tactic: simp only [div_eq_mul_inv]
state_before: F : Type ?u.56766
G : Type ?u.56769
α : Type u_1
M : Type ?u.56775
N : Type ?u.56778
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit c
⊢ a / c = b / c ↔ a = b

tactic: exact Units.mul_left_inj h.inv.unit'
state_before: F : Type ?u.56766
G : Type ?u.56769
α : Type u_1
M : Type ?u.56775
N : Type ?u.56778
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit c
⊢ a * c⁻¹ = b * c⁻¹ ↔ a = b
Theorem: Nat.dist_succ_succ
File: Mathlib/Data/Nat/Dist.lean

tactic: simp [dist.def, succ_sub_succ]
state_before: i j : ℕ
⊢ dist (succ i) (succ j) = dist i j
Theorem: exp_sum
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: rw [exp_sum_of_commute, Finset.noncommProd_eq_prod]
state_before: 𝕂 : Type u_3
𝔸 : Type u_2
inst✝³ : IsROrC 𝕂
inst✝² : NormedCommRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
ι : Type u_1
s : Finset ι
f : ι → 𝔸
⊢ exp 𝕂 (∑ i in s, f i) = ∏ i in s, exp 𝕂 (f i)

tactic: exact fun i _hi j _hj _ => Commute.all _ _
state_before: case h
𝕂 : Type u_3
𝔸 : Type u_2
inst✝³ : IsROrC 𝕂
inst✝² : NormedCommRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
ι : Type u_1
s : Finset ι
f : ι → 𝔸
⊢ Set.Pairwise ↑s fun i j => Commute (f i) (f j)

case h
𝕂 : Type u_3
𝔸 : Type u_2
inst✝³ : IsROrC 𝕂
inst✝² : NormedCommRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
ι : Type u_1
s : Finset ι
f : ι → 𝔸
⊢ Set.Pairwise ↑s fun i j => Commute (f i) (f j)
Theorem: Complex.arg_mul_cos_add_sin_mul_I_eq_toIocMod
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: have hi : toIocMod Real.two_pi_pos (-π) θ ∈ Set.Ioc (-π) π := by
  convert toIocMod_mem_Ioc _ _ θ
  ring
state_before: r : ℝ
hr : 0 < r
θ : ℝ
⊢ arg (↑r * (cos ↑θ + sin ↑θ * I)) = toIocMod two_pi_pos (-π) θ

tactic: convert arg_mul_cos_add_sin_mul_I hr hi using 3
state_before: r : ℝ
hr : 0 < r
θ : ℝ
hi : toIocMod two_pi_pos (-π) θ ∈ Set.Ioc (-π) π
⊢ arg (↑r * (cos ↑θ + sin ↑θ * I)) = toIocMod two_pi_pos (-π) θ

tactic: simp [toIocMod, cos_sub_int_mul_two_pi, sin_sub_int_mul_two_pi]
state_before: case h.e'_2.h.e'_1.h.e'_6
r : ℝ
hr : 0 < r
θ : ℝ
hi : toIocMod two_pi_pos (-π) θ ∈ Set.Ioc (-π) π
⊢ cos ↑θ + sin ↑θ * I = cos ↑(toIocMod two_pi_pos (-π) θ) + sin ↑(toIocMod two_pi_pos (-π) θ) * I

tactic: convert toIocMod_mem_Ioc _ _ θ
state_before: r : ℝ
hr : 0 < r
θ : ℝ
⊢ toIocMod two_pi_pos (-π) θ ∈ Set.Ioc (-π) π

tactic: ring
state_before: case h.e'_5.h.e'_4
r : ℝ
hr : 0 < r
θ : ℝ
⊢ π = -π + 2 * π
Theorem: lineMap_lt_right_iff_lt
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: rw [lineMap_apply_one]
state_before: k : Type u_1
E : Type u_2
PE : Type ?u.72601
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
h : r < 1
⊢ ↑(lineMap a b) r < b ↔ ↑(lineMap a b) r < ↑(lineMap a b) 1
Theorem: List.Sorted.insertionSort_eq
File: Mathlib/Data/List/Sort.lean

tactic: rw [insertionSort, Sorted.insertionSort_eq, orderedInsert, if_pos]
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
h : Sorted r (a :: b :: l)
⊢ insertionSort r (a :: b :: l) = a :: b :: l

tactic: exacts [rel_of_sorted_cons h _ (mem_cons_self _ _), h.tail]
state_before: case hc
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
h : Sorted r (a :: b :: l)
⊢ r a b

α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
h : Sorted r (a :: b :: l)
⊢ Sorted r (b :: l)
Theorem: TopologicalGroup.of_comm_of_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa using tendsto_id
state_before: α : Type u
β : Type v
G✝ : Type w
H : Type x
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Group G✝
inst✝³ : TopologicalGroup G✝
inst✝² : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u
inst✝¹ : CommGroup G
inst✝ : TopologicalSpace G
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hinv : Tendsto (fun x => x⁻¹) (𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
⊢ ∀ (x₀ : G), Tendsto (fun x => x₀ * x * x₀⁻¹) (𝓝 1) (𝓝 1)
Theorem: Equiv.asEmbedding_range
File: Mathlib/Logic/Embedding/Set.lean

tactic: simp
state_before: α✝ : Sort u
β✝ : Sort v
f : α✝ ≃ β✝
α : Sort u_1
β : Type u_2
p : β → Prop
e : α ≃ Subtype p
x : β
hs : x ∈ setOf p
⊢ ↑(asEmbedding e) (↑e.symm { val := x, property := hs }) = x