tasksource/leandojo huggingface dataset:
Theorem: gauge_lt_one_eq_self_of_open
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: refine' (gauge_lt_one_subset_self hs₁ ‹_› <| absorbent_nhds_zero <| hs₂.mem_nhds hs₀).antisymm _
state_before: 𝕜 : Type ?u.194308
E : Type u_1
F : Type ?u.194314
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs₁ : Convex ℝ s
hs₀ : 0 ∈ s
hs₂ : IsOpen s
⊢ {x | gauge s x < 1} = s

tactic: convert interior_subset_gauge_lt_one s
state_before: 𝕜 : Type ?u.194308
E : Type u_1
F : Type ?u.194314
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs₁ : Convex ℝ s
hs₀ : 0 ∈ s
hs₂ : IsOpen s
⊢ s ⊆ {x | gauge s x < 1}

tactic: exact hs₂.interior_eq.symm
state_before: case h.e'_3
𝕜 : Type ?u.194308
E : Type u_1
F : Type ?u.194314
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul ℝ E
hs₁ : Convex ℝ s
hs₀ : 0 ∈ s
hs₂ : IsOpen s
⊢ s = interior s
Theorem: List.prod_eq_one_iff
File: Mathlib/Data/List/BigOperators/Lemmas.lean

tactic: rw [List.eq_replicate.2 ⟨_, h⟩, prod_replicate, one_pow]
state_before: ι : Type ?u.6108
α : Type ?u.6111
M : Type u_1
N : Type ?u.6117
P : Type ?u.6120
M₀ : Type ?u.6123
G : Type ?u.6126
R : Type ?u.6129
inst✝ : CanonicallyOrderedMonoid M
l : List M
h : ∀ (x : M), x ∈ l → x = 1
⊢ prod l = 1

tactic: exact (length l)
state_before: ι : Type ?u.6108
α : Type ?u.6111
M : Type u_1
N : Type ?u.6117
P : Type ?u.6120
M₀ : Type ?u.6123
G : Type ?u.6126
R : Type ?u.6129
inst✝ : CanonicallyOrderedMonoid M
l : List M
h : ∀ (x : M), x ∈ l → x = 1
⊢ ℕ

ι : Type ?u.6108
α : Type ?u.6111
M : Type u_1
N : Type ?u.6117
P : Type ?u.6120
M₀ : Type ?u.6123
G : Type ?u.6126
R : Type ?u.6129
inst✝ : CanonicallyOrderedMonoid M
l : List M
h : ∀ (x : M), x ∈ l → x = 1
⊢ length l = ?m.7940

tactic: rfl
state_before: ι : Type ?u.6108
α : Type ?u.6111
M : Type u_1
N : Type ?u.6117
P : Type ?u.6120
M₀ : Type ?u.6123
G : Type ?u.6126
R : Type ?u.6129
inst✝ : CanonicallyOrderedMonoid M
l : List M
h : ∀ (x : M), x ∈ l → x = 1
⊢ length l = length l
Theorem: isGLB_Ioo
File: Mathlib/Order/Bounds/Basic.lean

tactic: cases' eq_or_lt_of_le (le_sup_right : a ≤ x ⊔ a) with h₁ h₂
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝³ : Preorder α
inst✝² : Preorder β
s t : Set α
a✝ b✝ : α
inst✝¹ : SemilatticeSup γ
inst✝ : DenselyOrdered γ
a b : γ
h : a < b
x : γ
hx : x ∈ lowerBounds (Ioo a b)
⊢ x ≤ a

tactic: obtain ⟨y, lty, ylt⟩ := exists_between h₂
state_before: case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝³ : Preorder α
inst✝² : Preorder β
s t : Set α
a✝ b✝ : α
inst✝¹ : SemilatticeSup γ
inst✝ : DenselyOrdered γ
a b : γ
h : a < b
x : γ
hx : x ∈ lowerBounds (Ioo a b)
h₂ : a < x ⊔ a
⊢ x ≤ a

tactic: apply (not_lt_of_le (sup_le (hx ⟨lty, ylt.trans_le (sup_le _ h.le)⟩) lty.le) ylt).elim
state_before: case inr.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝³ : Preorder α
inst✝² : Preorder β
s t : Set α
a✝ b✝ : α
inst✝¹ : SemilatticeSup γ
inst✝ : DenselyOrdered γ
a b : γ
h : a < b
x : γ
hx : x ∈ lowerBounds (Ioo a b)
h₂ : a < x ⊔ a
y : γ
lty : a < y
ylt : y < x ⊔ a
⊢ x ≤ a

tactic: obtain ⟨u, au, ub⟩ := exists_between h
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝³ : Preorder α
inst✝² : Preorder β
s t : Set α
a✝ b✝ : α
inst✝¹ : SemilatticeSup γ
inst✝ : DenselyOrdered γ
a b : γ
h : a < b
x : γ
hx : x ∈ lowerBounds (Ioo a b)
h₂ : a < x ⊔ a
y : γ
lty : a < y
ylt : y < x ⊔ a
⊢ x ≤ b

tactic: apply (hx ⟨au, ub⟩).trans ub.le
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝³ : Preorder α
inst✝² : Preorder β
s t : Set α
a✝ b✝ : α
inst✝¹ : SemilatticeSup γ
inst✝ : DenselyOrdered γ
a b : γ
h : a < b
x : γ
hx : x ∈ lowerBounds (Ioo a b)
h₂ : a < x ⊔ a
y : γ
lty : a < y
ylt : y < x ⊔ a
u : γ
au : a < u
ub : u < b
⊢ x ≤ b

tactic: exact h₁.symm ▸ le_sup_left
state_before: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝³ : Preorder α
inst✝² : Preorder β
s t : Set α
a✝ b✝ : α
inst✝¹ : SemilatticeSup γ
inst✝ : DenselyOrdered γ
a b : γ
h : a < b
x : γ
hx : x ∈ lowerBounds (Ioo a b)
h₁ : a = x ⊔ a
⊢ x ≤ a
Theorem: IsUnit.div_div_cancel_left
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, mul_right_comm, h.mul_inv_cancel, one_mul]
state_before: F : Type ?u.67029
G : Type ?u.67032
α : Type u_1
M : Type ?u.67038
N : Type ?u.67041
inst✝ : DivisionCommMonoid α
a b c d : α
h : IsUnit a
⊢ a / b / a = b⁻¹
Theorem: IsCoprime.dvd_of_dvd_mul_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: let ⟨a, b, H⟩ := H1
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x z
H2 : x ∣ y * z
⊢ x ∣ y

tactic: rw [← mul_one y, ← H, mul_add, ← mul_assoc, mul_left_comm]
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x z
H2 : x ∣ y * z
a b : R
H : a * x + b * z = 1
⊢ x ∣ y

tactic: exact dvd_add (dvd_mul_left _ _) (H2.mul_left _)
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H1 : IsCoprime x z
H2 : x ∣ y * z
a b : R
H : a * x + b * z = 1
⊢ x ∣ y * a * x + b * (y * z)
Theorem: mem_nhds_discrete
File: Mathlib/Topology/Order.lean

tactic: rw [nhds_discrete, mem_pure]
state_before: α : Type u_1
t t₁ t₂ : TopologicalSpace α
s✝ : Set α
inst✝¹ : TopologicalSpace α
inst✝ : DiscreteTopology α
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ x ∈ s
Theorem: tendsto_rpow_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: rw [tendsto_atTop_atTop]
state_before: y : ℝ
hy : 0 < y
⊢ Tendsto (fun x => x ^ y) atTop atTop

tactic: intro b
state_before: y : ℝ
hy : 0 < y
⊢ ∀ (b : ℝ), ∃ i, ∀ (a : ℝ), i ≤ a → b ≤ a ^ y

tactic: use max b 0 ^ (1 / y)
state_before: y : ℝ
hy : 0 < y
b : ℝ
⊢ ∃ i, ∀ (a : ℝ), i ≤ a → b ≤ a ^ y

tactic: intro x hx
state_before: y : ℝ
hy : 0 < y
b : ℝ
⊢ ∀ (a : ℝ), max b 0 ^ (1 / y) ≤ a → b ≤ a ^ y

tactic: exact
  le_of_max_le_left
    (by
      convert rpow_le_rpow (rpow_nonneg_of_nonneg (le_max_right b 0) (1 / y)) hx (le_of_lt hy)
        using 1
      rw [← rpow_mul (le_max_right b 0), (eq_div_iff (ne_of_gt hy)).mp rfl, Real.rpow_one])
state_before: y : ℝ
hy : 0 < y
b x : ℝ
hx : max b 0 ^ (1 / y) ≤ x
⊢ b ≤ x ^ y

tactic: convert rpow_le_rpow (rpow_nonneg_of_nonneg (le_max_right b 0) (1 / y)) hx (le_of_lt hy)
  using 1
state_before: y : ℝ
hy : 0 < y
b x : ℝ
hx : max b 0 ^ (1 / y) ≤ x
⊢ max b ?m.720 ≤ x ^ y

tactic: rw [← rpow_mul (le_max_right b 0), (eq_div_iff (ne_of_gt hy)).mp rfl, Real.rpow_one]
state_before: case h.e'_3
y : ℝ
hy : 0 < y
b x : ℝ
hx : max b 0 ^ (1 / y) ≤ x
⊢ max b ?m.720 = (max b 0 ^ (1 / y)) ^ y
Theorem: List.mem_inter_iff
File: Std/Data/List/Lemmas.lean

tactic: cases l₁ <;> simp [List.inter, mem_filter]
state_before: α : Type u_1
inst✝ : DecidableEq α
x : α
l₁ l₂ : List α
⊢ x ∈ List.inter l₁ l₂ ↔ x ∈ l₁ ∧ x ∈ l₂
Theorem: Finset.disjSups_left_comm
File: Mathlib/Data/Finset/Sups.lean

tactic: simp_rw [← disjSups_assoc, disjSups_comm s]
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s t u v : Finset α
⊢ s ○ (t ○ u) = t ○ (s ○ u)
Theorem: Function.Involutive.ite_not
File: Mathlib/Logic/Function/Basic.lean

tactic: rw [apply_ite f, h, ite_not]
state_before: α : Sort u
f : α → α
h : Involutive f
P : Prop
inst✝ : Decidable P
x : α
⊢ f (if P then x else f x) = if ¬P then x else f x
Theorem: DiffContOnCl.two_pi_i_inv_smul_circleIntegral_sub_inv_smul
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

tactic: have hR : 0 < R := not_le.mp (ball_eq_empty.not.mp (Set.nonempty_of_mem hw).ne_empty)
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
⊢ ((2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - w)⁻¹ • f z) = f w

tactic: refine' two_pi_I_inv_smul_circleIntegral_sub_inv_smul_of_differentiable_on_off_countable
  countable_empty hw _ _
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
hR : 0 < R
⊢ ((2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - w)⁻¹ • f z) = f w

tactic: simpa only [closure_ball c hR.ne.symm] using hf.continuousOn
state_before: case refine'_1
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
hR : 0 < R
⊢ ContinuousOn (fun z => f z) (closedBall c R)

tactic: simpa only [diff_empty] using fun z hz => hf.differentiableAt isOpen_ball hz
state_before: case refine'_2
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
hR : 0 < R
⊢ ∀ (x : ℂ), x ∈ ball c R \ ∅ → DifferentiableAt ℂ (fun z => f z) x
Theorem: CategoryTheory.IsPullback.isoPullback_inv_snd
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: simp [Iso.inv_comp_eq]
state_before: C : Type u₁
inst✝¹ : Category C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
h : IsPullback fst snd f g
inst✝ : HasPullback f g
⊢ (isoPullback h).inv ≫ snd = pullback.snd
Theorem: Polynomial.eq_of_degrees_lt_of_eval_index_eq
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: refine' eq_of_degree_sub_lt_of_eval_index_eq _ hvs _ eval_fg
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_f_lt : degree f < ↑(card s)
degree_g_lt : degree g < ↑(card s)
eval_fg : ∀ (i : ι), i ∈ s → eval (v i) f = eval (v i) g
⊢ f = g

tactic: rw [← mem_degreeLT] at degree_f_lt degree_g_lt⊢
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_f_lt : degree f < ↑(card s)
degree_g_lt : degree g < ↑(card s)
eval_fg : ∀ (i : ι), i ∈ s → eval (v i) f = eval (v i) g
⊢ degree (f - g) < ↑(card s)

tactic: exact Submodule.sub_mem _ degree_f_lt degree_g_lt
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_f_lt : f ∈ degreeLT R (card s)
degree_g_lt : g ∈ degreeLT R (card s)
eval_fg : ∀ (i : ι), i ∈ s → eval (v i) f = eval (v i) g
⊢ f - g ∈ degreeLT R (card s)
Theorem: CompositionSeries.isMaximal_eraseTop_top
File: Mathlib/Order/JordanHolder.lean

tactic: have : s.length - 1 + 1 = s.length := by
  conv_rhs => rw [← Nat.succ_sub_one s.length]; rw [Nat.succ_sub h]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
⊢ IsMaximal (top (eraseTop s)) (top s)

tactic: rw [top_eraseTop, top]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
this : s.length - 1 + 1 = s.length
⊢ IsMaximal (top (eraseTop s)) (top s)

tactic: convert s.step ⟨s.length - 1, Nat.sub_lt h zero_lt_one⟩
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
this : s.length - 1 + 1 = s.length
⊢ IsMaximal (series s { val := s.length - 1, isLt := (_ : s.length - 1 < s.length + 1) }) (series s (Fin.last s.length))

tactic: ext
state_before: case h.e'_5.h.e'_5
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
this : s.length - 1 + 1 = s.length
⊢ Fin.last s.length = Fin.succ { val := s.length - 1, isLt := (_ : s.length - 1 < s.length) }

tactic: simp [this]
state_before: case h.e'_5.h.e'_5.h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
this : s.length - 1 + 1 = s.length
⊢ ↑(Fin.last s.length) = ↑(Fin.succ { val := s.length - 1, isLt := (_ : s.length - 1 < s.length) })

tactic: conv_rhs => rw [← Nat.succ_sub_one s.length]; rw [Nat.succ_sub h]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
h : 0 < s.length
⊢ s.length - 1 + 1 = s.length
Theorem: MeasureTheory.Measure.LebesgueDecomposition.zero_mem_measurableLE
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.86195
m : MeasurableSpace α
μ ν : Measure α
A : Set α
x✝ : MeasurableSet A
⊢ (∫⁻ (x : α) in A, OfNat.ofNat 0 x ∂μ) ≤ ↑↑ν A
Theorem: untrop_sum_eq_sInf_image
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: rcases s.eq_empty_or_nonempty with (rfl | h)
state_before: R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
s : Finset S
f : S → Tropical (WithTop R)
⊢ untrop (∑ i in s, f i) = sInf (untrop ∘ f '' ↑s)

tactic: simp only [Set.image_empty, coe_empty, sum_empty, WithTop.sInf_empty, untrop_zero]
state_before: case inl
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
f : S → Tropical (WithTop R)
⊢ untrop (∑ i in ∅, f i) = sInf (untrop ∘ f '' ↑∅)

tactic: rw [← inf'_eq_csInf_image _ h, inf'_eq_inf, Finset.untrop_sum']
state_before: case inr
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
s : Finset S
f : S → Tropical (WithTop R)
h : Finset.Nonempty s
⊢ untrop (∑ i in s, f i) = sInf (untrop ∘ f '' ↑s)
Theorem: Finset.disjoint_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [disjoint_singleton_left, mem_singleton]
state_before: α : Type u_1
β : Type ?u.75361
γ : Type ?u.75364
f : α → β
s t u : Finset α
a b : α
⊢ _root_.Disjoint {a} {b} ↔ a ≠ b
Theorem: Prod.map_leftInverse
File: Mathlib/Data/Prod/Basic.lean

tactic: inhabit δ
state_before: α : Type u_4
β : Type u_1
γ : Type u_3
δ : Type u_2
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
b : β
⊢ f₁ (f₂ b) = b

tactic: exact congr_arg Prod.fst (h (b, default))
state_before: α : Type u_4
β : Type u_1
γ : Type u_3
δ : Type u_2
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
b : β
inhabited_h : Inhabited δ
⊢ f₁ (f₂ b) = b

tactic: inhabit β
state_before: α : Type u_4
β : Type u_1
γ : Type u_3
δ : Type u_2
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
d : δ
⊢ g₁ (g₂ d) = d

tactic: exact congr_arg Prod.snd (h (default, d))
state_before: α : Type u_4
β : Type u_1
γ : Type u_3
δ : Type u_2
inst✝¹ : Nonempty β
inst✝ : Nonempty δ
f₁ : α → β
g₁ : γ → δ
f₂ : β → α
g₂ : δ → γ
h : LeftInverse (map f₁ g₁) (map f₂ g₂)
d : δ
inhabited_h : Inhabited β
⊢ g₁ (g₂ d) = d
Theorem: Filter.hasBasis_self
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [hasBasis_iff, id, and_assoc]
state_before: α : Type u_1
β : Type ?u.22063
γ : Type ?u.22066
ι : Sort ?u.22069
ι' : Sort ?u.22072
l✝ l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
l : Filter α
P : Set α → Prop
⊢ HasBasis l (fun s => s ∈ l ∧ P s) id ↔ ∀ (t : Set α), t ∈ l → ∃ r, r ∈ l ∧ P r ∧ r ⊆ t

tactic: exact forall_congr' fun s =>
  ⟨fun h => h.1, fun h => ⟨h, fun ⟨t, hl, _, hts⟩ => mem_of_superset hl hts⟩⟩
state_before: α : Type u_1
β : Type ?u.22063
γ : Type ?u.22066
ι : Sort ?u.22069
ι' : Sort ?u.22072
l✝ l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
l : Filter α
P : Set α → Prop
⊢ (∀ (t : Set α), t ∈ l ↔ ∃ i, i ∈ l ∧ P i ∧ i ⊆ t) ↔ ∀ (t : Set α), t ∈ l → ∃ r, r ∈ l ∧ P r ∧ r ⊆ t
Theorem: IsRingHom.map_zero
File: Mathlib/Deprecated/Ring.lean

tactic: rw [hf.map_add]
state_before: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
⊢ f 0 = f (0 + 0) - f 0

tactic: simp
state_before: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
⊢ f 0 = f 0 + f 0 - f 0

tactic: simp
state_before: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
⊢ f (0 + 0) - f 0 = 0
Theorem: ball_mul_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [mul_comm, mul_ball_one]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ ball 1 δ * s = thickening δ s
Theorem: CategoryTheory.ProjectiveResolution.ofComplex_sq_10_comm
File: Mathlib/CategoryTheory/Abelian/Projective.lean

tactic: simp only [ofComplex_X, ChainComplex.single₀_obj_X_0, ChainComplex.single₀_obj_X_succ,
  ComplexShape.down_Rel, not_true, ChainComplex.single₀_obj_X_d, comp_zero, ofComplex_d,
  eqToHom_refl, Category.id_comp, dite_eq_ite, ite_true]
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
inst✝ : EnoughProjectives C
Z : C
⊢ 0 ≫ HomologicalComplex.d ((ChainComplex.single₀ C).obj Z) 1 0 =
    HomologicalComplex.d (ofComplex Z) 1 0 ≫ Projective.π Z

tactic: exact (exact_d_f (Projective.π Z)).w.symm
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Abelian C
inst✝ : EnoughProjectives C
Z : C
⊢ 0 =
    (ChainComplex.mkAux (over Z) (syzygies (Projective.π Z)) (syzygies (d (Projective.π Z))) (d (Projective.π Z))
          (d (d (Projective.π Z)))
          (_ :
            {
                      fst :=
                        syzygies
                          { fst := over Z,
                                snd := { fst := syzygies (Projective.π Z), snd := d (Projective.π Z) } }.2.snd,
                      snd :=
                        {
                          fst :=
                            d
                              { fst := over Z,
                                    snd := { fst := syzygies (Projective.π Z), snd := d (Projective.π Z) } }.2.snd,
                          snd :=
                            (_ :
                              d
                                    { fst := over Z,
                                          snd :=
                                            { fst := syzygies (Projective.π Z), snd := d (Projective.π Z) } }.2.snd ≫
                                  { fst := over Z,
                                        snd := { fst := syzygies (Projective.π Z), snd := d (Projective.π Z) } }.2.snd =
                                0) } }.snd.fst ≫
                { fst := over Z, snd := { fst := syzygies (Projective.π Z), snd := d (Projective.π Z) } }.snd.snd =
              0)
          (fun t =>
            { fst := syzygies t.snd.snd.snd.snd.fst,
              snd :=
                { fst := d t.snd.snd.snd.snd.fst, snd := (_ : d t.snd.snd.snd.snd.fst ≫ t.snd.snd.snd.snd.fst = 0) } })
          0).d₀ ≫
      Projective.π Z
Theorem: padicValNat.div_of_dvd
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: p a b : ℕ
hp : Fact (Nat.Prime p)
h : b ∣ a
⊢ padicValNat p (a / b) = padicValNat p a - padicValNat p b

tactic: obtain ⟨k, rfl⟩ := h
state_before: case inr
p a b : ℕ
hp : Fact (Nat.Prime p)
h : b ∣ a
ha : a ≠ 0
⊢ padicValNat p (a / b) = padicValNat p a - padicValNat p b

tactic: obtain ⟨hb, hk⟩ := mul_ne_zero_iff.mp ha
state_before: case inr.intro
p b : ℕ
hp : Fact (Nat.Prime p)
k : ℕ
ha : b * k ≠ 0
⊢ padicValNat p (b * k / b) = padicValNat p (b * k) - padicValNat p b

tactic: rw [mul_comm, k.mul_div_cancel hb.bot_lt, padicValNat.mul hk hb, Nat.add_sub_cancel]
state_before: case inr.intro.intro
p b : ℕ
hp : Fact (Nat.Prime p)
k : ℕ
ha : b * k ≠ 0
hb : b ≠ 0
hk : k ≠ 0
⊢ padicValNat p (b * k / b) = padicValNat p (b * k) - padicValNat p b

tactic: simp
state_before: case inl
p b : ℕ
hp : Fact (Nat.Prime p)
h : b ∣ 0
⊢ padicValNat p (0 / b) = padicValNat p 0 - padicValNat p b
Theorem: Ordnode.toList_node
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [toList, foldr, foldr_cons_eq_toList]
state_before: α : Type u_1
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
⊢ toList (node s l x r) = toList l ++ x :: toList r

tactic: rfl
state_before: α : Type u_1
s : ℕ
l : Ordnode α
x : α
r : Ordnode α
⊢ toList l ++ x :: foldr List.cons r [] = toList l ++ x :: toList r
Theorem: FirstOrder.Language.Equiv.realize_formula
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Formula.Realize, Formula.Realize, ← g.realize_boundedFormula φ, iff_eq_eq,
  Unique.eq_default (g ∘ default)]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.653346
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
g : M ≃[L] N
φ : Formula L α
v : α → M
⊢ Formula.Realize φ (↑g ∘ v) ↔ Formula.Realize φ v
Theorem: Polynomial.trinomial_trailing_coeff'
File: Mathlib/Data/Polynomial/UnitTrinomial.lean

tactic: rw [trinomial_def, coeff_add, coeff_add, coeff_C_mul_X_pow, coeff_C_mul_X_pow, coeff_C_mul_X_pow,
  if_pos rfl, if_neg hkm.ne, if_neg (hkm.trans hmn).ne, add_zero, add_zero]
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
⊢ coeff (trinomial k m n u v w) k = u
Theorem: contDiffOn_top_iff_deriv_of_open
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [contDiffOn_top_iff_derivWithin hs.uniqueDiffOn]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.3026855
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : IsOpen s₂
⊢ ContDiffOn 𝕜 ⊤ f₂ s₂ ↔ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (deriv f₂) s₂

tactic: exact Iff.rfl.and <| contDiffOn_congr fun _ => derivWithin_of_open hs
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.3026855
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
hs : IsOpen s₂
⊢ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (derivWithin f₂ s₂) s₂ ↔
    DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ⊤ (deriv f₂) s₂
Theorem: Set.image_image2_distrib
File: Mathlib/Data/Set/NAry.lean

tactic: simp_rw [image_image2, image2_image_left, image2_image_right, h_distrib]
state_before: α : Type u_3
α' : Type u_5
β : Type u_4
β' : Type u_6
γ : Type u_2
γ' : Type ?u.43409
δ : Type u_1
δ' : Type ?u.43415
ε : Type ?u.43418
ε' : Type ?u.43421
ζ : Type ?u.43424
ζ' : Type ?u.43427
ν : Type ?u.43430
f f'✝ : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
⊢ g '' image2 f s t = image2 f' (g₁ '' s) (g₂ '' t)
Theorem: Complex.AbsTheory.abs_mul
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [normSq_mul, Real.sqrt_mul (normSq_nonneg _)]
state_before: z w : ℂ
⊢ Real.sqrt (↑normSq (z * w)) = Real.sqrt (↑normSq z) * Real.sqrt (↑normSq w)
Theorem: Set.preimage_congr
File: Mathlib/Data/Set/Image.lean

tactic: congr with x
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.8381
ι : Sort ?u.8384
ι' : Sort ?u.8387
f✝ : α → β
g✝ : β → γ
f g : α → β
s : Set β
h : ∀ (x : α), f x = g x
⊢ f ⁻¹' s = g ⁻¹' s

tactic: simp [h]
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.8381
ι : Sort ?u.8384
ι' : Sort ?u.8387
f✝ : α → β
g✝ : β → γ
f g : α → β
s : Set β
h : ∀ (x : α), f x = g x
x : α
⊢ x ∈ f ⁻¹' s ↔ x ∈ g ⁻¹' s