1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.einfsep_pair_le_right
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [pair_comm]
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hxy : x ≠ y
⊢ {x, y}.einfsep ≤ edist y x
state_after: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hxy : x ≠ y
⊢ {y, x}.einfsep ≤ edist y x

tactic: exact einfsep_pair_le_left hxy.symm
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hxy : x ≠ y
⊢ {y, x}.einfsep ≤ edist y x
state_after: no goals
Theorem: MeasureTheory.SignedMeasure.singularPart_add
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

tactic: refine
  (eq_singularPart _ (s.rnDeriv μ + t.rnDeriv μ)
      ((mutuallySingular_singularPart s μ).add_left (mutuallySingular_singularPart t μ))
      ?_).symm
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : s.HaveLebesgueDecomposition μ
inst✝ : t.HaveLebesgueDecomposition μ
⊢ (s + t).singularPart μ = s.singularPart μ + t.singularPart μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : s.HaveLebesgueDecomposition μ
inst✝ : t.HaveLebesgueDecomposition μ
⊢ s + t = s.singularPart μ + t.singularPart μ + μ.withDensityᵥ (s.rnDeriv μ + t.rnDeriv μ)

tactic: rw [withDensityᵥ_add (integrable_rnDeriv s μ) (integrable_rnDeriv t μ), add_assoc,
  add_comm (t.singularPart μ), add_assoc, add_comm _ (t.singularPart μ),
  singularPart_add_withDensity_rnDeriv_eq, ← add_assoc,
  singularPart_add_withDensity_rnDeriv_eq]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : s.HaveLebesgueDecomposition μ
inst✝ : t.HaveLebesgueDecomposition μ
⊢ s + t = s.singularPart μ + t.singularPart μ + μ.withDensityᵥ (s.rnDeriv μ + t.rnDeriv μ)
state_after: no goals
Theorem: SimpleGraph.induceHom_comp
File: Mathlib/Combinatorics/SimpleGraph/Maps.lean

tactic: ext x
state_before: V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
G'' : SimpleGraph X
s : Set V
t : Set W
r : Set X
φ : G →g G'
φst : Set.MapsTo (⇑φ) s t
ψ : G' →g G''
ψtr : Set.MapsTo (⇑ψ) t r
⊢ (induceHom ψ ψtr).comp (induceHom φ φst) = induceHom (ψ.comp φ) ⋯
state_after: case h.a
V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
G'' : SimpleGraph X
s : Set V
t : Set W
r : Set X
φ : G →g G'
φst : Set.MapsTo (⇑φ) s t
ψ : G' →g G''
ψtr : Set.MapsTo (⇑ψ) t r
x : ↑s
⊢ ↑(((induceHom ψ ψtr).comp (induceHom φ φst)) x) = ↑((induceHom (ψ.comp φ) ⋯) x)

tactic: rfl
state_before: case h.a
V : Type u_1
W : Type u_2
X : Type u_3
G : SimpleGraph V
G' : SimpleGraph W
u v : V
G'' : SimpleGraph X
s : Set V
t : Set W
r : Set X
φ : G →g G'
φst : Set.MapsTo (⇑φ) s t
ψ : G' →g G''
ψtr : Set.MapsTo (⇑ψ) t r
x : ↑s
⊢ ↑(((induceHom ψ ψtr).comp (induceHom φ φst)) x) = ↑((induceHom (ψ.comp φ) ⋯) x)
state_after: no goals
Theorem: QuotientGroup.equivQuotientZPowOfEquiv_refl
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: ext x
state_before: G : Type u
inst✝⁵ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝⁴ : Group H
M : Type x
inst✝³ : Monoid M
φ : G →* H
A B C : Type u
inst✝² : CommGroup A
inst✝¹ : CommGroup B
inst✝ : CommGroup C
f : A →* B
g : B →* A
e : A ≃* B
d : B ≃* C
n : ℤ
⊢ MulEquiv.refl (A ⧸ (zpowGroupHom n).range) = equivQuotientZPowOfEquiv (MulEquiv.refl A) n
state_after: case h
G : Type u
inst✝⁵ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝⁴ : Group H
M : Type x
inst✝³ : Monoid M
φ : G →* H
A B C : Type u
inst✝² : CommGroup A
inst✝¹ : CommGroup B
inst✝ : CommGroup C
f : A →* B
g : B →* A
e : A ≃* B
d : B ≃* C
n : ℤ
x : A ⧸ (zpowGroupHom n).range
⊢ (MulEquiv.refl (A ⧸ (zpowGroupHom n).range)) x = (equivQuotientZPowOfEquiv (MulEquiv.refl A) n) x

tactic: rw [← Quotient.out_eq' x]
state_before: case h
G : Type u
inst✝⁵ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝⁴ : Group H
M : Type x
inst✝³ : Monoid M
φ : G →* H
A B C : Type u
inst✝² : CommGroup A
inst✝¹ : CommGroup B
inst✝ : CommGroup C
f : A →* B
g : B →* A
e : A ≃* B
d : B ≃* C
n : ℤ
x : A ⧸ (zpowGroupHom n).range
⊢ (MulEquiv.refl (A ⧸ (zpowGroupHom n).range)) x = (equivQuotientZPowOfEquiv (MulEquiv.refl A) n) x
state_after: case h
G : Type u
inst✝⁵ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝⁴ : Group H
M : Type x
inst✝³ : Monoid M
φ : G →* H
A B C : Type u
inst✝² : CommGroup A
inst✝¹ : CommGroup B
inst✝ : CommGroup C
f : A →* B
g : B →* A
e : A ≃* B
d : B ≃* C
n : ℤ
x : A ⧸ (zpowGroupHom n).range
⊢ (MulEquiv.refl (A ⧸ (zpowGroupHom n).range)) (Quotient.mk'' (Quotient.out' x)) =
    (equivQuotientZPowOfEquiv (MulEquiv.refl A) n) (Quotient.mk'' (Quotient.out' x))

tactic: rfl
state_before: case h
G : Type u
inst✝⁵ : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝⁴ : Group H
M : Type x
inst✝³ : Monoid M
φ : G →* H
A B C : Type u
inst✝² : CommGroup A
inst✝¹ : CommGroup B
inst✝ : CommGroup C
f : A →* B
g : B →* A
e : A ≃* B
d : B ≃* C
n : ℤ
x : A ⧸ (zpowGroupHom n).range
⊢ (MulEquiv.refl (A ⧸ (zpowGroupHom n).range)) (Quotient.mk'' (Quotient.out' x)) =
    (equivQuotientZPowOfEquiv (MulEquiv.refl A) n) (Quotient.mk'' (Quotient.out' x))
state_after: no goals
Theorem: IntermediateField.finSepDegree_adjoin_simple_eq_finrank_iff
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: rw [finSepDegree_adjoin_simple_eq_natSepDegree F E halg, adjoin.finrank halg.isIntegral,
  natSepDegree_eq_natDegree_iff _ (minpoly.ne_zero halg.isIntegral)]
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
α : E
halg : IsAlgebraic F α
⊢ finSepDegree F ↥F⟮α⟯ = finrank F ↥F⟮α⟯ ↔ (minpoly F α).Separable
state_after: no goals
Theorem: Rat.normalize.reduced
File: .lake/packages/batteries/Batteries/Data/Rat/Basic.lean

tactic: match num, num.eq_nat_or_neg with
| _, ⟨_, .inl rfl⟩ => rfl
| _, ⟨_, .inr rfl⟩ => rw [Int.neg_div, Int.natAbs_neg, Int.natAbs_neg]; rfl
state_before: num : Int
den g : Nat
den_nz : den ≠ 0
e : g = num.natAbs.gcd den
⊢ (num.div ↑g).natAbs = num.natAbs / g
state_after: no goals

tactic: rfl
state_before: num : Int
den g : Nat
den_nz : den ≠ 0
w✝ : Nat
e : g = (↑w✝).natAbs.gcd den
⊢ ((↑w✝).div ↑g).natAbs = (↑w✝).natAbs / g
state_after: no goals

tactic: rw [Int.neg_div, Int.natAbs_neg, Int.natAbs_neg]
state_before: num : Int
den g : Nat
den_nz : den ≠ 0
w✝ : Nat
e : g = (-↑w✝).natAbs.gcd den
⊢ ((-↑w✝).div ↑g).natAbs = (-↑w✝).natAbs / g
state_after: num : Int
den g : Nat
den_nz : den ≠ 0
w✝ : Nat
e : g = (-↑w✝).natAbs.gcd den
⊢ ((↑w✝).div ↑g).natAbs = (↑w✝).natAbs / g

tactic: rfl
state_before: num : Int
den g : Nat
den_nz : den ≠ 0
w✝ : Nat
e : g = (-↑w✝).natAbs.gcd den
⊢ ((↑w✝).div ↑g).natAbs = (↑w✝).natAbs / g
state_after: no goals
Theorem: CategoryTheory.ShortComplex.comp_liftCycles
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

tactic: rw [assoc, hk, comp_zero]
state_before: C : Type u_1
inst✝² : Category.{?u.199814, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
k : A ⟶ S.X₂
hk : k ≫ S.g = 0
inst✝ : S.HasLeftHomology
A' : C
α : A' ⟶ A
⊢ (α ≫ k) ≫ S.g = 0
state_after: no goals

tactic: aesop_cat
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
k : A ⟶ S.X₂
hk : k ≫ S.g = 0
inst✝ : S.HasLeftHomology
A' : C
α : A' ⟶ A
⊢ α ≫ S.liftCycles k hk = S.liftCycles (α ≫ k) ⋯
state_after: no goals
Theorem: edist_div_right
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: simp only [div_eq_mul_inv, edist_mul_right]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁶ : PseudoEMetricSpace X
inst✝⁵ : Group G
inst✝⁴ : MulAction G X
inst✝³ : IsometricSMul G X
inst✝² : DivInvMonoid M
inst✝¹ : PseudoEMetricSpace M
inst✝ : IsometricSMul Mᵐᵒᵖ M
a b c : M
⊢ edist (a / c) (b / c) = edist a b
state_after: no goals
Theorem: Set.iUnionLift_const
File: Mathlib/Data/Set/UnionLift.lean

tactic: let ⟨i, hi⟩ := Set.mem_iUnion.1 (hT c.prop)
state_before: α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
c : ↑T
ci : (i : ι) → ↑(S i)
hci : ∀ (i : ι), ↑(ci i) = ↑c
cβ : β
h : ∀ (i : ι), f i (ci i) = cβ
⊢ iUnionLift S f hf T hT c = cβ
state_after: α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
c : ↑T
ci : (i : ι) → ↑(S i)
hci : ∀ (i : ι), ↑(ci i) = ↑c
cβ : β
h : ∀ (i : ι), f i (ci i) = cβ
i : ι
hi : ↑c ∈ S i
⊢ iUnionLift S f hf T hT c = cβ

tactic: have : ci i = ⟨c, hi⟩ := Subtype.ext (hci i)
state_before: α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
c : ↑T
ci : (i : ι) → ↑(S i)
hci : ∀ (i : ι), ↑(ci i) = ↑c
cβ : β
h : ∀ (i : ι), f i (ci i) = cβ
i : ι
hi : ↑c ∈ S i
⊢ iUnionLift S f hf T hT c = cβ
state_after: α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
c : ↑T
ci : (i : ι) → ↑(S i)
hci : ∀ (i : ι), ↑(ci i) = ↑c
cβ : β
h : ∀ (i : ι), f i (ci i) = cβ
i : ι
hi : ↑c ∈ S i
this : ci i = ⟨↑c, hi⟩
⊢ iUnionLift S f hf T hT c = cβ

tactic: rw [iUnionLift_of_mem _ hi, ← this, h]
state_before: α : Type u_1
ι : Sort u_3
β : Sort u_2
S : ι → Set α
f : (i : ι) → ↑(S i) → β
hf : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩
T : Set α
hT : T ⊆ iUnion S
hT' : T = iUnion S
c : ↑T
ci : (i : ι) → ↑(S i)
hci : ∀ (i : ι), ↑(ci i) = ↑c
cβ : β
h : ∀ (i : ι), f i (ci i) = cβ
i : ι
hi : ↑c ∈ S i
this : ci i = ⟨↑c, hi⟩
⊢ iUnionLift S f hf T hT c = cβ
state_after: no goals
Theorem: List.eraseP_append_left
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: by_cases h' : p x <;> simp [h']
state_before: α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
h : a ∈ x :: xs
⊢ eraseP p (x :: xs ++ l₂) = eraseP p (x :: xs) ++ l₂
state_after: case neg
α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
h : a ∈ x :: xs
h' : ¬p x = true
⊢ eraseP p (xs ++ l₂) = eraseP p xs ++ l₂

tactic: rw [eraseP_append_left pa l₂ ((mem_cons.1 h).resolve_left (mt _ h'))]
state_before: case neg
α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
h : a ∈ x :: xs
h' : ¬p x = true
⊢ eraseP p (xs ++ l₂) = eraseP p xs ++ l₂
state_after: α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
h : a ∈ x :: xs
h' : ¬p x = true
⊢ a = x → p x = true

tactic: intro | rfl => exact pa
state_before: α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
h : a ∈ x :: xs
h' : ¬p x = true
⊢ a = x → p x = true
state_after: no goals

tactic: exact pa
state_before: α : Type u_1
p : α → Bool
a : α
pa : p a = true
x : α
xs l₂ : List α
x✝ : a = x
h : a ∈ a :: xs
h' : ¬p a = true
⊢ p a = true
state_after: no goals
Theorem: Multiset.countP_filter
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [countP_eq_card_filter]
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝¹ : DecidablePred p
q : α → Prop
inst✝ : DecidablePred q
s : Multiset α
⊢ countP p (filter q s) = countP (fun a => p a ∧ q a) s
state_after: no goals
Theorem: Summable.ofStar
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

tactic: simpa only [star_star] using hf.star
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : AddCommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : StarAddMonoid α
inst✝ : ContinuousStar α
f : β → α
a : α
hf : Summable fun b => Star.star (f b)
⊢ Summable f
state_after: no goals
Theorem: Associates.le_one_iff
File: Mathlib/Algebra/Associated.lean

tactic: rw [← Associates.bot_eq_one, le_bot_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : Associates α
⊢ p ≤ 1 ↔ p = 1
state_after: no goals
Theorem: IsOpen.measure_eq_zero_iff
File: Mathlib/MeasureTheory/Measure/OpenPos.lean

tactic: simpa only [not_lt, nonpos_iff_eq_zero, not_nonempty_iff_eq_empty] using
  not_congr (hU.measure_pos_iff μ)
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
m : MeasurableSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : T2Space Y
μ ν : Measure X
inst✝ : μ.IsOpenPosMeasure
s U F : Set X
x : X
hU : IsOpen U
⊢ μ U = 0 ↔ U = ∅
state_after: no goals
Theorem: ModularGroup.three_lt_four_mul_im_sq_of_mem_fdo
File: Mathlib/NumberTheory/Modular.lean

tactic: have : 1 < z.re * z.re + z.im * z.im := by simpa [Complex.normSq_apply] using h.1
state_before: g : SL(2, ℤ)
z : ℍ
h : z ∈ 𝒟ᵒ
⊢ 3 < 4 * z.im ^ 2
state_after: g : SL(2, ℤ)
z : ℍ
h : z ∈ 𝒟ᵒ
this : 1 < z.re * z.re + z.im * z.im
⊢ 3 < 4 * z.im ^ 2

tactic: have := h.2
state_before: g : SL(2, ℤ)
z : ℍ
h : z ∈ 𝒟ᵒ
this : 1 < z.re * z.re + z.im * z.im
⊢ 3 < 4 * z.im ^ 2
state_after: g : SL(2, ℤ)
z : ℍ
h : z ∈ 𝒟ᵒ
this✝ : 1 < z.re * z.re + z.im * z.im
this : |z.re| < 1 / 2
⊢ 3 < 4 * z.im ^ 2

tactic: cases abs_cases z.re <;> nlinarith
state_before: g : SL(2, ℤ)
z : ℍ
h : z ∈ 𝒟ᵒ
this✝ : 1 < z.re * z.re + z.im * z.im
this : |z.re| < 1 / 2
⊢ 3 < 4 * z.im ^ 2
state_after: no goals

tactic: simpa [Complex.normSq_apply] using h.1
state_before: g : SL(2, ℤ)
z : ℍ
h : z ∈ 𝒟ᵒ
⊢ 1 < z.re * z.re + z.im * z.im
state_after: no goals
Theorem: Nat.factorial_mul_pow_sub_le_factorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: calc
  _ ≤ n ! * (n + 1) ^ (m - n) := Nat.mul_le_mul_left _ (Nat.pow_le_pow_left n.le_succ _)
  _ ≤ _ := by simpa [hnm] using @Nat.factorial_mul_pow_le_factorial n (m - n)
state_before: m✝ n✝ n m : ℕ
hnm : n ≤ m
⊢ n ! * n ^ (m - n) ≤ m !
state_after: no goals

tactic: simpa [hnm] using @Nat.factorial_mul_pow_le_factorial n (m - n)
state_before: m✝ n✝ n m : ℕ
hnm : n ≤ m
⊢ n ! * (n + 1) ^ (m - n) ≤ m !
state_after: no goals
Theorem: Nat.ofDigits_zmodeq'
File: Mathlib/Data/Nat/Digits.lean

tactic: induction' L with d L ih
state_before: n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
L : List ℕ
⊢ ofDigits b L ≡ ofDigits b' L [ZMOD ↑k]
state_after: case nil
n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
⊢ ofDigits b [] ≡ ofDigits b' [] [ZMOD ↑k]

case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [ZMOD ↑k]
⊢ ofDigits b (d :: L) ≡ ofDigits b' (d :: L) [ZMOD ↑k]

tactic: rfl
state_before: case nil
n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
⊢ ofDigits b [] ≡ ofDigits b' [] [ZMOD ↑k]
state_after: no goals

tactic: dsimp [ofDigits]
state_before: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [ZMOD ↑k]
⊢ ofDigits b (d :: L) ≡ ofDigits b' (d :: L) [ZMOD ↑k]
state_after: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [ZMOD ↑k]
⊢ ↑d + b * ofDigits b L ≡ ↑d + b' * ofDigits b' L [ZMOD ↑k]

tactic: dsimp [Int.ModEq] at *
state_before: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b ≡ b' [ZMOD ↑k]
d : ℕ
L : List ℕ
ih : ofDigits b L ≡ ofDigits b' L [ZMOD ↑k]
⊢ ↑d + b * ofDigits b L ≡ ↑d + b' * ofDigits b' L [ZMOD ↑k]
state_after: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b % ↑k = b' % ↑k
d : ℕ
L : List ℕ
ih : ofDigits b L % ↑k = ofDigits b' L % ↑k
⊢ (↑d + b * ofDigits b L) % ↑k = (↑d + b' * ofDigits b' L) % ↑k

tactic: conv_lhs => rw [Int.add_emod, Int.mul_emod, h, ih]
state_before: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b % ↑k = b' % ↑k
d : ℕ
L : List ℕ
ih : ofDigits b L % ↑k = ofDigits b' L % ↑k
⊢ (↑d + b * ofDigits b L) % ↑k = (↑d + b' * ofDigits b' L) % ↑k
state_after: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b % ↑k = b' % ↑k
d : ℕ
L : List ℕ
ih : ofDigits b L % ↑k = ofDigits b' L % ↑k
⊢ (↑d % ↑k + b' % ↑k * (ofDigits b' L % ↑k) % ↑k) % ↑k = (↑d + b' * ofDigits b' L) % ↑k

tactic: conv_rhs => rw [Int.add_emod, Int.mul_emod]
state_before: case cons
n : ℕ
b b' : ℤ
k : ℕ
h : b % ↑k = b' % ↑k
d : ℕ
L : List ℕ
ih : ofDigits b L % ↑k = ofDigits b' L % ↑k
⊢ (↑d % ↑k + b' % ↑k * (ofDigits b' L % ↑k) % ↑k) % ↑k = (↑d + b' * ofDigits b' L) % ↑k
state_after: no goals
Theorem: isLittleO_pow_pow_of_abs_lt_left
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: refine (IsLittleO.of_norm_left ?_).of_norm_right
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
r₁ r₂ : ℝ
h : |r₁| < |r₂|
⊢ (fun n => r₁ ^ n) =o[atTop] fun n => r₂ ^ n
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
r₁ r₂ : ℝ
h : |r₁| < |r₂|
⊢ (fun x => ‖r₁ ^ x‖) =o[atTop] fun x => ‖r₂ ^ x‖

tactic: exact (isLittleO_pow_pow_of_lt_left (abs_nonneg r₁) h).congr (pow_abs r₁) (pow_abs r₂)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
r₁ r₂ : ℝ
h : |r₁| < |r₂|
⊢ (fun x => ‖r₁ ^ x‖) =o[atTop] fun x => ‖r₂ ^ x‖
state_after: no goals
Theorem: Finset.image_add_right_Ioc
File: Mathlib/Algebra/Order/Interval/Finset.lean

tactic: rw [← map_add_right_Ioc, map_eq_image, addRightEmbedding, Embedding.coeFn_mk]
state_before: ι : Type u_1
α : Type u_2
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image (fun x => x + c) (Ioc a b) = Ioc (a + c) (b + c)
state_after: no goals
Theorem: toIcoDiv_add_right'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIcoDiv_add_zsmul' hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp (a + p) b = toIcoDiv hp a b - 1
state_after: no goals
Theorem: Erased.map_out
File: Mathlib/Data/Erased.lean

tactic: simp [map]
state_before: α : Sort u_1
β : Sort u_2
f : α → β
a : Erased α
⊢ (map f a).out = f a.out
state_after: no goals
Theorem: Option.map_injective'
File: Mathlib/Data/Option/Basic.lean

tactic: simp only [← map_some', h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f g : α → β
h : Option.map f = Option.map g
x : α
⊢ some (f x) = some (g x)
state_after: no goals
Theorem: FiniteDimensional.finrank_pos_iff
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

tactic: rw [← rank_pos_iff_nontrivial (R := R), ← finrank_eq_rank]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M'
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
inst✝⁵ : Module R M₁
inst✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ 0 < finrank R M ↔ Nontrivial M
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M'
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
inst✝⁵ : Module R M₁
inst✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ 0 < finrank R M ↔ 0 < ↑(finrank R M)

tactic: norm_cast
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹¹ : Ring R
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : AddCommGroup M'
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
inst✝⁵ : Module R M₁
inst✝⁴ : Nontrivial R
inst✝³ : NoZeroSMulDivisors R M
inst✝² : StrongRankCondition R
inst✝¹ : Module.Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ 0 < finrank R M ↔ 0 < ↑(finrank R M)
state_after: no goals
Theorem: PowerSeries.invOneSubPow_eq_inv_one_sub_pow
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: rw [inv_pow]
state_before: S : Type u_1
inst✝ : CommRing S
d : ℕ
⊢ invOneSubPow d = (Units.mkOfMulEqOne (1 - X) (mk 1) ⋯)⁻¹ ^ (d + 1)
state_after: S : Type u_1
inst✝ : CommRing S
d : ℕ
⊢ invOneSubPow d = (Units.mkOfMulEqOne (1 - X) (mk 1) ⋯ ^ (d + 1))⁻¹

tactic: exact (DivisionMonoid.inv_eq_of_mul _ (invOneSubPow d) <| by
  rw [← Units.val_eq_one, Units.val_mul, Units.val_pow_eq_pow_val]
  exact (invOneSubPow d).inv_val).symm
state_before: S : Type u_1
inst✝ : CommRing S
d : ℕ
⊢ invOneSubPow d = (Units.mkOfMulEqOne (1 - X) (mk 1) ⋯ ^ (d + 1))⁻¹
state_after: no goals

tactic: rw [← Units.val_eq_one, Units.val_mul, Units.val_pow_eq_pow_val]
state_before: S : Type u_1
inst✝ : CommRing S
d : ℕ
⊢ Units.mkOfMulEqOne (1 - X) (mk 1) ⋯ ^ (d + 1) * invOneSubPow d = 1
state_after: S : Type u_1
inst✝ : CommRing S
d : ℕ
⊢ ↑(Units.mkOfMulEqOne (1 - X) (mk 1) ⋯) ^ (d + 1) * ↑(invOneSubPow d) = 1

tactic: exact (invOneSubPow d).inv_val
state_before: S : Type u_1
inst✝ : CommRing S
d : ℕ
⊢ ↑(Units.mkOfMulEqOne (1 - X) (mk 1) ⋯) ^ (d + 1) * ↑(invOneSubPow d) = 1
state_after: no goals
Theorem: Set.Ioo_union_Ioo
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rcases le_total a b with hab | hab <;> rcases le_total c d with hcd | hcd <;>
  simp only [min_eq_left, min_eq_right, max_eq_left, max_eq_right, hab, hcd] at h₁ h₂
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : min a b < max c d
h₂ : min c d < max a b
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)
state_after: case inl.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : c ≤ d
h₁ : a < d
h₂ : c < b
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

case inl.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : d ≤ c
h₁ : a < c
h₂ : d < b
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

case inr.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : c ≤ d
h₁ : b < d
h₂ : c < a
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

case inr.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : d ≤ c
h₁ : b < c
h₂ : d < a
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

tactic: all_goals
  simp [*, min_eq_left_of_lt, min_eq_right_of_lt, max_eq_left_of_lt, max_eq_right_of_lt,
    le_of_lt h₂, le_of_lt h₁]
state_before: case inl.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : d ≤ c
h₁ : a < c
h₂ : d < b
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

case inr.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : c ≤ d
h₁ : b < d
h₂ : c < a
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)

case inr.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : d ≤ c
h₁ : b < c
h₂ : d < a
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)
state_after: no goals

tactic: exact Ioo_union_Ioo' h₂ h₁
state_before: case inl.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : c ≤ d
h₁ : a < d
h₂ : c < b
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)
state_after: no goals

tactic: simp [*, min_eq_left_of_lt, min_eq_right_of_lt, max_eq_left_of_lt, max_eq_right_of_lt,
  le_of_lt h₂, le_of_lt h₁]
state_before: case inr.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : d ≤ c
h₁ : b < c
h₂ : d < a
⊢ Ioo a b ∪ Ioo c d = Ioo (min a c) (max b d)
state_after: no goals
Theorem: LinearMap.mul_toMatrix'
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: simp only [B.toMatrix₂'_comp, transpose_transpose, toMatrix'_toLin']
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
M✝ : Type u_4
M₁ : Type u_5
M₂ : Type u_6
M₁' : Type u_7
M₂' : Type u_8
n : Type u_9
m : Type u_10
n' : Type u_11
m' : Type u_12
ι : Type u_13
inst✝¹⁰ : CommSemiring R
inst✝⁹ : Semiring R₁
inst✝⁸ : Semiring R₂
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
M : Matrix n' n R
⊢ M * toMatrix₂' B = toMatrix₂' (B ∘ₗ toLin' Mᵀ)
state_after: no goals