tasksource/leandojo huggingface dataset:
Theorem: spectrum.map_inv
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: refine' Set.eq_of_subset_of_subset (fun k hk => _) fun k hk => _
state_before: 𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
⊢ (σ ↑a)⁻¹ = σ ↑a⁻¹

tactic: rw [Set.mem_inv] at hk
state_before: case refine'_1
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k ∈ (σ ↑a)⁻¹
⊢ k ∈ σ ↑a⁻¹

tactic: have : k ≠ 0 := by simpa only [inv_inv] using inv_ne_zero (ne_zero_of_mem_of_unit hk)
state_before: case refine'_1
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k⁻¹ ∈ σ ↑a
⊢ k ∈ σ ↑a⁻¹

tactic: lift k to 𝕜ˣ using isUnit_iff_ne_zero.mpr this
state_before: case refine'_1
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k⁻¹ ∈ σ ↑a
this : k ≠ 0
⊢ k ∈ σ ↑a⁻¹

tactic: rw [← Units.val_inv_eq_inv_val k] at hk
state_before: case refine'_1.intro
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜ˣ
hk : (↑k)⁻¹ ∈ σ ↑a
this : ↑k ≠ 0
⊢ ↑k ∈ σ ↑a⁻¹

tactic: exact inv_mem_iff.mp hk
state_before: case refine'_1.intro
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜ˣ
hk : ↑k⁻¹ ∈ σ ↑a
this : ↑k ≠ 0
⊢ ↑k ∈ σ ↑a⁻¹

tactic: simpa only [inv_inv] using inv_ne_zero (ne_zero_of_mem_of_unit hk)
state_before: 𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k⁻¹ ∈ σ ↑a
⊢ k ≠ 0

tactic: lift k to 𝕜ˣ using isUnit_iff_ne_zero.mpr (ne_zero_of_mem_of_unit hk)
state_before: case refine'_2
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜
hk : k ∈ σ ↑a⁻¹
⊢ k ∈ (σ ↑a)⁻¹

tactic: simpa only [Units.val_inv_eq_inv_val] using inv_mem_iff.mp hk
state_before: case refine'_2.intro
𝕜 : Type u
A : Type v
inst✝² : Field 𝕜
inst✝¹ : Ring A
inst✝ : Algebra 𝕜 A
a : Aˣ
k : 𝕜ˣ
hk : ↑k ∈ σ ↑a⁻¹
⊢ ↑k ∈ (σ ↑a)⁻¹
Theorem: CategoryTheory.Limits.PushoutCocone.epi_inr_of_is_pushout_of_epi
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: simp [← cancel_epi f, t.condition_assoc, i]
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
ht : IsColimit t
inst✝ : Epi f
W : C
h k : t.pt ⟶ W
i : inr t ≫ h = inr t ≫ k
⊢ inl t ≫ h = inl t ≫ k
Theorem: Nat.odd_mul
File: Mathlib/Data/Nat/Parity.lean

tactic: simp [not_or, even_mul]
state_before: m n : ℕ
⊢ Odd (m * n) ↔ Odd m ∧ Odd n
Theorem: div_le_div_flip
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [div_eq_mul_inv b, mul_comm]
state_before: α✝ : Type u
inst✝⁵ : Group α✝
inst✝⁴ : LinearOrder α✝
inst✝³ : CovariantClass α✝ α✝ (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α✝
α : Type u_1
inst✝² : CommGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a / b ≤ b / a ↔ a ≤ b

tactic: exact div_le_inv_mul_iff
state_before: α✝ : Type u
inst✝⁵ : Group α✝
inst✝⁴ : LinearOrder α✝
inst✝³ : CovariantClass α✝ α✝ (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α✝
α : Type u_1
inst✝² : CommGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a / b ≤ a⁻¹ * b ↔ a ≤ b
Theorem: Pmf.toOuterMeasure_apply_singleton
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: refine' (p.toOuterMeasure_apply {a}).trans ((tsum_eq_single a fun b hb => _).trans _)
state_before: α : Type u_1
β : Type ?u.24121
γ : Type ?u.24124
p : Pmf α
s t : Set α
a : α
⊢ ↑(toOuterMeasure p) {a} = ↑p a

tactic: exact ite_eq_right_iff.2 fun hb' => False.elim <| hb hb'
state_before: case refine'_1
α : Type u_1
β : Type ?u.24121
γ : Type ?u.24124
p : Pmf α
s t : Set α
a b : α
hb : b ≠ a
⊢ Set.indicator {a} (↑p) b = 0

tactic: exact ite_eq_left_iff.2 fun ha' => False.elim <| ha' rfl
state_before: case refine'_2
α : Type u_1
β : Type ?u.24121
γ : Type ?u.24124
p : Pmf α
s t : Set α
a : α
⊢ Set.indicator {a} (↑p) a = ↑p a
Theorem: Rat.mkRat_add_mkRat
File: Std/Data/Rat/Lemmas.lean

tactic: rw [← normalize_eq_mkRat z₁, ← normalize_eq_mkRat z₂, normalize_add_normalize, normalize_eq_mkRat]
state_before: n₁ n₂ : Int
d₁ d₂ : Nat
z₁ : d₁ ≠ 0
z₂ : d₂ ≠ 0
⊢ mkRat n₁ d₁ + mkRat n₂ d₂ = mkRat (n₁ * ↑d₂ + n₂ * ↑d₁) (d₁ * d₂)
Theorem: HasStrictDerivAt.sub
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hf : HasStrictDerivAt f f' x
hg : HasStrictDerivAt g g' x
⊢ HasStrictDerivAt (fun x => f x - g x) (f' - g') x
Theorem: Polynomial.hasseDeriv_C
File: Mathlib/Data/Polynomial/HasseDeriv.lean

tactic: rw [← monomial_zero_left, hasseDeriv_monomial, Nat.choose_eq_zero_of_lt hk, Nat.cast_zero,
  MulZeroClass.zero_mul, monomial_zero_right]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
r : R
hk : 0 < k
⊢ ↑(hasseDeriv k) (↑C r) = 0
Theorem: finrank_span_le_card
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: simpa using rank_span_le (K := K) s
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
s : Set V
inst✝ : Fintype ↑s
⊢ Module.rank K { x // x ∈ span K s } ≤ ↑(Finset.card (Set.toFinset s))
Theorem: Nat.Primes.coe_pnat_injective
File: Mathlib/Data/PNat/Prime.lean

tactic: injection h
state_before: p q : Primes
h : ↑p = ↑q
⊢ ↑p = ↑q
Theorem: Matrix.diagonal_map
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.70038
m : Type ?u.70041
n : Type u_1
o : Type ?u.70047
m' : o → Type ?u.70052
n' : o → Type ?u.70057
R : Type ?u.70060
S : Type ?u.70063
α : Type v
β : Type w
γ : Type ?u.70070
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
d : n → α
⊢ map (diagonal d) f = diagonal fun m => f (d m)

tactic: simp only [diagonal_apply, map_apply]
state_before: case a.h
l : Type ?u.70038
m : Type ?u.70041
n : Type u_1
o : Type ?u.70047
m' : o → Type ?u.70052
n' : o → Type ?u.70057
R : Type ?u.70060
S : Type ?u.70063
α : Type v
β : Type w
γ : Type ?u.70070
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
d : n → α
i✝ x✝ : n
⊢ map (diagonal d) f i✝ x✝ = diagonal (fun m => f (d m)) i✝ x✝

tactic: split_ifs <;> simp [h]
state_before: case a.h
l : Type ?u.70038
m : Type ?u.70041
n : Type u_1
o : Type ?u.70047
m' : o → Type ?u.70052
n' : o → Type ?u.70057
R : Type ?u.70060
S : Type ?u.70063
α : Type v
β : Type w
γ : Type ?u.70070
inst✝² : DecidableEq n
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
d : n → α
i✝ x✝ : n
⊢ f (if i✝ = x✝ then d i✝ else 0) = if i✝ = x✝ then f (d i✝) else 0
Theorem: Path.Homotopy.transAssocReparamAux_zero
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

tactic: simp [transAssocReparamAux]
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ transAssocReparamAux 0 = 0

tactic: norm_num
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ 4 < 0 → (if 0 ≤ 2 then 4⁻¹ else 2⁻¹) = 0
Theorem: WittVector.neg_coeff
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: simp [Neg.neg, eval, Matrix.cons_fin_one, coeff_mk]
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x : 𝕎 R
n : ℕ
⊢ coeff (-x) n = peval (wittNeg p n) ![x.coeff]
Theorem: Inducing.isSeparable_preimage
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: have : SeparableSpace s := hs.separableSpace
state_before: α : Type u
β : Type v
X : Type ?u.307583
ι : Type ?u.307586
inst✝¹ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
f : β → α
inst✝ : TopologicalSpace β
hf : Inducing f
s : Set α
hs : IsSeparable s
⊢ IsSeparable (f ⁻¹' s)

tactic: have : SecondCountableTopology s := UniformSpace.secondCountable_of_separable _
state_before: α : Type u
β : Type v
X : Type ?u.307583
ι : Type ?u.307586
inst✝¹ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
f : β → α
inst✝ : TopologicalSpace β
hf : Inducing f
s : Set α
hs : IsSeparable s
this : SeparableSpace ↑s
⊢ IsSeparable (f ⁻¹' s)

tactic: have : Inducing ((mapsTo_preimage f s).restrict _ _ _) :=
  (hf.comp inducing_subtype_val).codRestrict _
state_before: α : Type u
β : Type v
X : Type ?u.307583
ι : Type ?u.307586
inst✝¹ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
f : β → α
inst✝ : TopologicalSpace β
hf : Inducing f
s : Set α
hs : IsSeparable s
this✝ : SeparableSpace ↑s
this : SecondCountableTopology ↑s
⊢ IsSeparable (f ⁻¹' s)

tactic: have := this.secondCountableTopology
state_before: α : Type u
β : Type v
X : Type ?u.307583
ι : Type ?u.307586
inst✝¹ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
f : β → α
inst✝ : TopologicalSpace β
hf : Inducing f
s : Set α
hs : IsSeparable s
this✝¹ : SeparableSpace ↑s
this✝ : SecondCountableTopology ↑s
this : Inducing (MapsTo.restrict f (f ⁻¹' s) s (_ : MapsTo f (f ⁻¹' s) s))
⊢ IsSeparable (f ⁻¹' s)

tactic: exact isSeparable_of_separableSpace_subtype _
state_before: α : Type u
β : Type v
X : Type ?u.307583
ι : Type ?u.307586
inst✝¹ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
f : β → α
inst✝ : TopologicalSpace β
hf : Inducing f
s : Set α
hs : IsSeparable s
this✝² : SeparableSpace ↑s
this✝¹ : SecondCountableTopology ↑s
this✝ : Inducing (MapsTo.restrict f (f ⁻¹' s) s (_ : MapsTo f (f ⁻¹' s) s))
this : SecondCountableTopology ↑(f ⁻¹' s)
⊢ IsSeparable (f ⁻¹' s)
Theorem: padicValNat.pow_two_sub_pow
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: simp only [← PartENat.natCast_inj, Nat.cast_add]
state_before: R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ padicValNat 2 (x ^ n - y ^ n) + 1 = padicValNat 2 (x + y) + padicValNat 2 (x - y) + padicValNat 2 n

tactic: iterate 4 rw [padicValNat_def, PartENat.natCast_get]
state_before: R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ ↑(padicValNat 2 (x ^ n - y ^ n)) + ↑1 = ↑(padicValNat 2 (x + y)) + ↑(padicValNat 2 (x - y)) + ↑(padicValNat 2 n)

tactic: rw [padicValNat_def, PartENat.natCast_get]
state_before: R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ multiplicity 2 (x ^ n - y ^ n) + ↑1 = multiplicity 2 (x + y) + multiplicity 2 (x - y) + ↑(padicValNat 2 n)

R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < x - y

R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < x - y

R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < x + y

R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < x + y

R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < x ^ n - y ^ n

R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < x ^ n - y ^ n

tactic: convert Nat.two_pow_sub_pow hxy hx hneven using 2
state_before: R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ multiplicity 2 (x ^ n - y ^ n) + ↑1 = multiplicity 2 (x + y) + multiplicity 2 (x - y) + multiplicity 2 n

tactic: exact hn
state_before: R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < n

tactic: exact Nat.sub_pos_of_lt hyx
state_before: R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < x - y

tactic: linarith
state_before: R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < x + y

tactic: simp only [tsub_pos_iff_lt, pow_lt_pow_of_lt_left hyx (@zero_le' _ y _) hn]
state_before: R : Type ?u.877564
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : 0 < n
hneven : Even n
⊢ 0 < x ^ n - y ^ n
Theorem: Units.mk0_prod
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: classical induction s using Finset.induction_on <;> simp [*]
state_before: ι : Type ?u.972913
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommGroupWithZero β
s : Finset α
f : α → β
h : ∏ b in s, f b ≠ 0
⊢ mk0 (∏ b in s, f b) h = ∏ b in Finset.attach s, mk0 (f ↑b) (_ : f ↑b = 0 → False)

tactic: induction s using Finset.induction_on <;> simp [*]
state_before: ι : Type ?u.972913
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommGroupWithZero β
s : Finset α
f : α → β
h : ∏ b in s, f b ≠ 0
⊢ mk0 (∏ b in s, f b) h = ∏ b in Finset.attach s, mk0 (f ↑b) (_ : f ↑b = 0 → False)
Theorem: Range.isSubmonoid
File: Mathlib/Deprecated/Submonoid.lean

tactic: rw [← Set.image_univ]
state_before: M : Type u_2
inst✝² : Monoid M
s : Set M
A : Type ?u.30160
inst✝¹ : AddMonoid A
t : Set A
γ : Type u_1
inst✝ : Monoid γ
f : M → γ
hf : IsMonoidHom f
⊢ IsSubmonoid (Set.range f)

tactic: exact Univ.isSubmonoid.image hf
state_before: M : Type u_2
inst✝² : Monoid M
s : Set M
A : Type ?u.30160
inst✝¹ : AddMonoid A
t : Set A
γ : Type u_1
inst✝ : Monoid γ
f : M → γ
hf : IsMonoidHom f
⊢ IsSubmonoid (f '' Set.univ)
Theorem: Polynomial.C_mul_X_eq_monomial
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [← C_mul_X_pow_eq_monomial, pow_one]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ↑C a * X = ↑(monomial 1) a
Theorem: Nat.choose_pos
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: rw [Nat.eq_zero_of_le_zero hk]
state_before: x✝ : ℕ
hk : x✝ ≤ 0
⊢ 0 < choose 0 x✝

tactic: decide
state_before: x✝ : ℕ
hk : x✝ ≤ 0
⊢ 0 < choose 0 0

tactic: simp
state_before: n : ℕ
x✝ : 0 ≤ n + 1
⊢ 0 < choose (n + 1) 0

tactic: rw [choose_succ_succ]
state_before: n k : ℕ
hk : k + 1 ≤ n + 1
⊢ 0 < choose (n + 1) (k + 1)

tactic: exact add_pos_of_pos_of_nonneg (choose_pos (le_of_succ_le_succ hk)) (Nat.zero_le _)
state_before: n k : ℕ
hk : k + 1 ≤ n + 1
⊢ 0 < choose n k + choose n (succ k)
Theorem: Int.modEq_zero_iff_dvd
File: Mathlib/Data/Int/ModEq.lean

tactic: rw [ModEq, zero_emod, dvd_iff_emod_eq_zero]
state_before: m n a b c d : ℤ
⊢ a ≡ 0 [ZMOD n] ↔ n ∣ a
Theorem: PFunctor.M.corec_def
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: dsimp only [M.corec, M.mk]
state_before: F : PFunctor
X✝ : Type ?u.29252
f✝ : X✝ → Obj F X✝
X : Type u
f : X → Obj F X
x₀ : X
⊢ M.corec f x₀ = M.mk (M.corec f <$> f x₀)

tactic: congr with n
state_before: F : PFunctor
X✝ : Type ?u.29252
f✝ : X✝ → Obj F X✝
X : Type u
f : X → Obj F X
x₀ : X
⊢ { approx := sCorec f x₀, consistent := (_ : ∀ (n : ℕ), Agree (sCorec f x₀ n) (sCorec f x₀ (succ n))) } =
    {
      approx :=
        Approx.sMk
          ((fun i =>
              { approx := sCorec f i, consistent := (_ : ∀ (n : ℕ), Agree (sCorec f i n) (sCorec f i (succ n))) }) <$>
            f x₀),
      consistent :=
        (_ :
          AllAgree
            (Approx.sMk
              ((fun i =>
                  { approx := sCorec f i,
                    consistent := (_ : ∀ (n : ℕ), Agree (sCorec f i n) (sCorec f i (succ n))) }) <$>
                f x₀))) }

tactic: cases' n with n
state_before: case e_approx.h
F : PFunctor
X✝ : Type ?u.29252
f✝ : X✝ → Obj F X✝
X : Type u
f : X → Obj F X
x₀ : X
n : ℕ
⊢ sCorec f x₀ n =
    Approx.sMk
      ((fun i =>
          { approx := sCorec f i, consistent := (_ : ∀ (n : ℕ), Agree (sCorec f i n) (sCorec f i (succ n))) }) <$>
        f x₀)
      n

tactic: dsimp only [sCorec, Approx.sMk]
state_before: case e_approx.h.zero
F : PFunctor
X✝ : Type ?u.29252
f✝ : X✝ → Obj F X✝
X : Type u
f : X → Obj F X
x₀ : X
⊢ sCorec f x₀ zero =
    Approx.sMk
      ((fun i =>
          { approx := sCorec f i, consistent := (_ : ∀ (n : ℕ), Agree (sCorec f i n) (sCorec f i (succ n))) }) <$>
        f x₀)
      zero

tactic: dsimp only [sCorec, Approx.sMk]
state_before: case e_approx.h.succ
F : PFunctor
X✝ : Type ?u.29252
f✝ : X✝ → Obj F X✝
X : Type u
f : X → Obj F X
x₀ : X
n : ℕ
⊢ sCorec f x₀ (succ n) =
    Approx.sMk
      ((fun i =>
          { approx := sCorec f i, consistent := (_ : ∀ (n : ℕ), Agree (sCorec f i n) (sCorec f i (succ n))) }) <$>
        f x₀)
      (succ n)

tactic: cases h : f x₀
state_before: case e_approx.h.succ
F : PFunctor
X✝ : Type ?u.29252
f✝ : X✝ → Obj F X✝
X : Type u
f : X → Obj F X
x₀ : X
n : ℕ
⊢ (CofixA.intro (f x₀).fst fun i => sCorec f (Sigma.snd (f x₀) i) n) =
    CofixA.intro
      ((fun i =>
            { approx := sCorec f i, consistent := (_ : ∀ (n : ℕ), Agree (sCorec f i n) (sCorec f i (succ n))) }) <$>
          f x₀).fst
      fun i =>
      MIntl.approx
        (Sigma.snd
          ((fun i =>
              { approx := sCorec f i, consistent := (_ : ∀ (n : ℕ), Agree (sCorec f i n) (sCorec f i (succ n))) }) <$>
            f x₀)
          i)
        n

tactic: congr
state_before: case e_approx.h.succ.mk
F : PFunctor
X✝ : Type ?u.29252
f✝ : X✝ → Obj F X✝
X : Type u
f : X → Obj F X
x₀ : X
n : ℕ
fst✝ : F.A
snd✝ : B F fst✝ → X
h : f x₀ = { fst := fst✝, snd := snd✝ }
⊢ (CofixA.intro fst✝ fun i => sCorec f (snd✝ i) n) =
    CofixA.intro fst✝ fun i =>
      MIntl.approx
        (((fun i =>
              { approx := sCorec f i, consistent := (_ : ∀ (n : ℕ), Agree (sCorec f i n) (sCorec f i (succ n))) }) ∘
            snd✝)
          i)
        n
Theorem: Subgroup.map_eq_range_iff
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [f.range_eq_map, map_eq_map_iff, codisjoint_iff, top_sup_eq]
state_before: G : Type u_1
G' : Type ?u.592426
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.592435
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ f : G →* N
H : Subgroup G
⊢ map f H = range f ↔ Codisjoint H (ker f)
Theorem: Finsupp.total_equivMapDomain
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [equivMapDomain_eq_mapDomain, total_mapDomain]
state_before: α : Type u_1
M : Type ?u.371094
N : Type ?u.371097
P : Type ?u.371100
R : Type u_3
S : Type ?u.371106
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : Module R N
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R P
α' : Type u_2
M' : Type u_4
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
f : α ≃ α'
l : α →₀ R
⊢ ↑(Finsupp.total α' M' R v') (equivMapDomain f l) = ↑(Finsupp.total α M' R (v' ∘ ↑f)) l
Theorem: intervalIntegral.integral_interval_sub_interval_comm
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [sub_eq_add_neg, ← integral_symm,
  integral_interval_add_interval_comm hab hcd.symm (hac.trans hcd)]
state_before: ι : Type ?u.15965783
𝕜 : Type ?u.15965786
E : Type u_1
F : Type ?u.15965792
A : Type ?u.15965795
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d : ℝ
f g : ℝ → E
μ : MeasureTheory.Measure ℝ
hab : IntervalIntegrable f μ a b
hcd : IntervalIntegrable f μ c d
hac : IntervalIntegrable f μ a c
⊢ ((∫ (x : ℝ) in a..b, f x ∂μ) - ∫ (x : ℝ) in c..d, f x ∂μ) = (∫ (x : ℝ) in a..c, f x ∂μ) - ∫ (x : ℝ) in b..d, f x ∂μ
Theorem: Finsupp.comapDomain_smul
File: Mathlib/Data/Finsupp/Basic.lean

tactic: ext
state_before: α : Type u_4
β : Type u_3
γ : Type ?u.647265
ι : Type ?u.647268
M : Type u_1
M' : Type ?u.647274
N : Type ?u.647277
P : Type ?u.647280
G : Type ?u.647283
H : Type ?u.647286
R : Type u_2
S : Type ?u.647292
inst✝² : AddMonoid M
inst✝¹ : Monoid R
inst✝ : DistribMulAction R M
f : α → β
r : R
v : β →₀ M
hfv : Set.InjOn f (f ⁻¹' ↑v.support)
hfrv : optParam (Set.InjOn f (f ⁻¹' ↑(r • v).support)) (_ : Set.InjOn f (f ⁻¹' ↑(r • v).support))
⊢ comapDomain f (r • v) hfrv = r • comapDomain f v hfv

tactic: rfl
state_before: case h
α : Type u_4
β : Type u_3
γ : Type ?u.647265
ι : Type ?u.647268
M : Type u_1
M' : Type ?u.647274
N : Type ?u.647277
P : Type ?u.647280
G : Type ?u.647283
H : Type ?u.647286
R : Type u_2
S : Type ?u.647292
inst✝² : AddMonoid M
inst✝¹ : Monoid R
inst✝ : DistribMulAction R M
f : α → β
r : R
v : β →₀ M
hfv : Set.InjOn f (f ⁻¹' ↑v.support)
hfrv : optParam (Set.InjOn f (f ⁻¹' ↑(r • v).support)) (_ : Set.InjOn f (f ⁻¹' ↑(r • v).support))
a✝ : α
⊢ ↑(comapDomain f (r • v) hfrv) a✝ = ↑(r • comapDomain f v hfv) a✝
Theorem: aemeasurable_union_iff
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

tactic: simp only [union_eq_iUnion, aemeasurable_iUnion_iff, Bool.forall_bool, cond, and_comm]
state_before: ι : Type ?u.1736002
α : Type u_1
β : Type u_2
γ : Type ?u.1736011
δ : Type ?u.1736014
R : Type ?u.1736017
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : MeasureTheory.Measure α
s t : Set α
⊢ AEMeasurable f ↔ AEMeasurable f ∧ AEMeasurable f
Theorem: RatFunc.ofFractionRing_algebraMap
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [← mk_one, mk_one']
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
x : K[X]
⊢ { toFractionRing := ↑(algebraMap K[X] (FractionRing K[X])) x } = ↑(algebraMap K[X] (RatFunc K)) x
Theorem: Nat.cast_add
File: Mathlib/Data/Nat/Cast/Defs.lean

tactic: induction n <;> simp [add_succ, add_assoc, Nat.add_zero, Nat.cast_one, Nat.cast_zero, *]
state_before: R : Type u_1
inst✝ : AddMonoidWithOne R
m n : ℕ
⊢ ↑(m + n) = ↑m + ↑n
Theorem: List.rtake_nil
File: Mathlib/Data/List/Rdrop.lean

tactic: simp [rtake]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rtake [] n = []
Theorem: Units.isUnit_units_mul
File: Mathlib/Algebra/Group/Units.lean

tactic: have : IsUnit (↑u⁻¹ * (↑u * a)) := by exists u⁻¹ * v; rw [← hv, Units.val_mul]
state_before: α : Type u
M✝ : Type ?u.61791
N : Type ?u.61794
M : Type u_1
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
⊢ IsUnit a

tactic: rwa [← mul_assoc, Units.inv_mul, one_mul] at this
state_before: α : Type u
M✝ : Type ?u.61791
N : Type ?u.61794
M : Type u_1
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
this : IsUnit (↑u⁻¹ * (↑u * a))
⊢ IsUnit a

tactic: exists u⁻¹ * v
state_before: α : Type u
M✝ : Type ?u.61791
N : Type ?u.61794
M : Type u_1
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
⊢ IsUnit (↑u⁻¹ * (↑u * a))

tactic: rw [← hv, Units.val_mul]
state_before: α : Type u
M✝ : Type ?u.61791
N : Type ?u.61794
M : Type u_1
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
⊢ ↑(u⁻¹ * v) = ↑u⁻¹ * (↑u * a)
Theorem: Nat.ArithmeticFunction.intCoe_one
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext n
state_before: R : Type u_1
inst✝ : AddGroupWithOne R
⊢ ↑1 = 1

tactic: simp [one_apply]
state_before: case h
R : Type u_1
inst✝ : AddGroupWithOne R
n : ℕ
⊢ ↑↑1 n = ↑1 n
Theorem: Real.hasDerivAt_rpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: rcases ne_or_eq x 0 with (hx | rfl)
state_before: z x✝ y x p : ℝ
h : x ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x

tactic: replace h : 1 ≤ p := h.neg_resolve_left rfl
state_before: case inr
z x y p : ℝ
h : 0 ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0

tactic: apply hasDerivAt_of_hasDerivAt_of_ne fun x hx =>
  (hasStrictDerivAt_rpow_const_of_ne hx p).hasDerivAt
state_before: case inr
z x y p : ℝ
h : 1 ≤ p
⊢ HasDerivAt (fun x => x ^ p) (p * 0 ^ (p - 1)) 0

tactic: exacts [continuousAt_id.rpow_const (Or.inr (zero_le_one.trans h)),
  continuousAt_const.mul (continuousAt_id.rpow_const (Or.inr (sub_nonneg.2 h)))]
state_before: case inr.hf
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => x ^ p) 0

case inr.hg
z x y p : ℝ
h : 1 ≤ p
⊢ ContinuousAt (fun x => p * x ^ (p - 1)) 0

tactic: exact (hasStrictDerivAt_rpow_const_of_ne hx _).hasDerivAt
state_before: case inl
z x✝ y x p : ℝ
h : x ≠ 0 ∨ 1 ≤ p
hx : x ≠ 0
⊢ HasDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x