1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Function.mem_periodicOrbit_iff
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp only [periodicOrbit, Cycle.mem_coe_iff, List.mem_map, List.mem_range]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ y ∈ periodicOrbit f x ↔ ∃ n, f^[n] x = y
state_after: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ (∃ a < minimalPeriod f x, f^[a] x = y) ↔ ∃ n, f^[n] x = y

tactic: use fun ⟨a, _, ha'⟩ => ⟨a, ha'⟩
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ (∃ a < minimalPeriod f x, f^[a] x = y) ↔ ∃ n, f^[n] x = y
state_after: case mpr
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ (∃ n, f^[n] x = y) → ∃ a < minimalPeriod f x, f^[a] x = y

tactic: rintro ⟨n, rfl⟩
state_before: case mpr
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ (∃ n, f^[n] x = y) → ∃ a < minimalPeriod f x, f^[a] x = y
state_after: case mpr.intro
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ ∃ a < minimalPeriod f x, f^[a] x = f^[n] x

tactic: use n % minimalPeriod f x, mod_lt _ (minimalPeriod_pos_of_mem_periodicPts hx)
state_before: case mpr.intro
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ ∃ a < minimalPeriod f x, f^[a] x = f^[n] x
state_after: case right
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ f^[n % minimalPeriod f x] x = f^[n] x

tactic: rw [iterate_mod_minimalPeriod_eq]
state_before: case right
α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ f^[n % minimalPeriod f x] x = f^[n] x
state_after: no goals
Theorem: FiniteDimensional.proper_rclike
File: Mathlib/Analysis/RCLike/Lemmas.lean

tactic: letI : NormedSpace ℝ E := RestrictScalars.normedSpace ℝ K E
state_before: K : Type u_1
E : Type u_2
inst✝³ : RCLike K
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace K E
inst✝ : FiniteDimensional K E
⊢ ProperSpace E
state_after: K : Type u_1
E : Type u_2
inst✝³ : RCLike K
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace K E
inst✝ : FiniteDimensional K E
this : NormedSpace ℝ E := RestrictScalars.normedSpace ℝ K E
⊢ ProperSpace E

tactic: letI : FiniteDimensional ℝ E := FiniteDimensional.trans ℝ K E
state_before: K : Type u_1
E : Type u_2
inst✝³ : RCLike K
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace K E
inst✝ : FiniteDimensional K E
this : NormedSpace ℝ E := RestrictScalars.normedSpace ℝ K E
⊢ ProperSpace E
state_after: K : Type u_1
E : Type u_2
inst✝³ : RCLike K
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace K E
inst✝ : FiniteDimensional K E
this✝ : NormedSpace ℝ E := RestrictScalars.normedSpace ℝ K E
this : FiniteDimensional ℝ E := trans ℝ K E
⊢ ProperSpace E

tactic: infer_instance
state_before: K : Type u_1
E : Type u_2
inst✝³ : RCLike K
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace K E
inst✝ : FiniteDimensional K E
this✝ : NormedSpace ℝ E := RestrictScalars.normedSpace ℝ K E
this : FiniteDimensional ℝ E := trans ℝ K E
⊢ ProperSpace E
state_after: no goals
Theorem: Complex.cos_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← cosh_mul_I, add_mul, cosh_add, cosh_mul_I, cosh_mul_I, sinh_mul_I, sinh_mul_I,
  mul_mul_mul_comm, I_mul_I, mul_neg_one, sub_eq_add_neg]
state_before: x y : ℂ
⊢ cos (x + y) = cos x * cos y - sin x * sin y
state_after: no goals
Theorem: Real.exp_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [exp_log_eq_abs hx.ne']
state_before: x y : ℝ
hx : 0 < x
⊢ rexp (log x) = x
state_after: x y : ℝ
hx : 0 < x
⊢ |x| = x

tactic: exact abs_of_pos hx
state_before: x y : ℝ
hx : 0 < x
⊢ |x| = x
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_neg
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [map_setToSimpleFunc T h_add hf neg_zero, setToSimpleFunc, ← sum_neg_distrib]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ setToSimpleFunc T (map Neg.neg f) = -setToSimpleFunc T f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ ∑ x ∈ f.range, (T (↑f ⁻¹' {x})) (-x) = ∑ x ∈ f.range, -(T (↑f ⁻¹' {x})) x

tactic: exact Finset.sum_congr rfl fun x _ => ContinuousLinearMap.map_neg _ _
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f : α →ₛ E
hf : Integrable (↑f) μ
⊢ ∑ x ∈ f.range, (T (↑f ⁻¹' {x})) (-x) = ∑ x ∈ f.range, -(T (↑f ⁻¹' {x})) x
state_after: no goals
Theorem: sbtw_comm
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Sbtw, Sbtw, wbtw_comm, ← and_assoc, ← and_assoc, and_right_comm]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
⊢ Sbtw R x y z ↔ Sbtw R z y x
state_after: no goals
Theorem: Set.Iic.isCompl_inf_inf_of_isCompl_of_le
File: Mathlib/Order/ModularLattice.lean

tactic: constructor
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : BoundedOrder α
inst✝ : IsModularLattice α
a b c : α
h₁ : IsCompl b c
h₂ : b ≤ a
⊢ IsCompl ⟨a ⊓ b, ⋯⟩ ⟨a ⊓ c, ⋯⟩
state_after: case disjoint
α : Type u_1
inst✝² : Lattice α
inst✝¹ : BoundedOrder α
inst✝ : IsModularLattice α
a b c : α
h₁ : IsCompl b c
h₂ : b ≤ a
⊢ Disjoint ⟨a ⊓ b, ⋯⟩ ⟨a ⊓ c, ⋯⟩

case codisjoint
α : Type u_1
inst✝² : Lattice α
inst✝¹ : BoundedOrder α
inst✝ : IsModularLattice α
a b c : α
h₁ : IsCompl b c
h₂ : b ≤ a
⊢ Codisjoint ⟨a ⊓ b, ⋯⟩ ⟨a ⊓ c, ⋯⟩

tactic: simp [disjoint_iff, Subtype.ext_iff, inf_comm a c, inf_assoc a, ← inf_assoc b, h₁.inf_eq_bot]
state_before: case disjoint
α : Type u_1
inst✝² : Lattice α
inst✝¹ : BoundedOrder α
inst✝ : IsModularLattice α
a b c : α
h₁ : IsCompl b c
h₂ : b ≤ a
⊢ Disjoint ⟨a ⊓ b, ⋯⟩ ⟨a ⊓ c, ⋯⟩
state_after: no goals

tactic: simp only [Iic.codisjoint_iff, inf_comm a, IsModularLattice.inf_sup_inf_assoc]
state_before: case codisjoint
α : Type u_1
inst✝² : Lattice α
inst✝¹ : BoundedOrder α
inst✝ : IsModularLattice α
a b c : α
h₁ : IsCompl b c
h₂ : b ≤ a
⊢ Codisjoint ⟨a ⊓ b, ⋯⟩ ⟨a ⊓ c, ⋯⟩
state_after: case codisjoint
α : Type u_1
inst✝² : Lattice α
inst✝¹ : BoundedOrder α
inst✝ : IsModularLattice α
a b c : α
h₁ : IsCompl b c
h₂ : b ≤ a
⊢ (b ⊓ a ⊔ c) ⊓ a = a

tactic: simp [inf_of_le_left h₂, h₁.sup_eq_top]
state_before: case codisjoint
α : Type u_1
inst✝² : Lattice α
inst✝¹ : BoundedOrder α
inst✝ : IsModularLattice α
a b c : α
h₁ : IsCompl b c
h₂ : b ≤ a
⊢ (b ⊓ a ⊔ c) ⊓ a = a
state_after: no goals
Theorem: Subgroup.Normal.mem_comm
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: have : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ H := nH.conj_mem (a * b) h a⁻¹
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
nH : H.Normal
a b : G
h : a * b ∈ H
⊢ b * a ∈ H
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
nH : H.Normal
a b : G
h : a * b ∈ H
this : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ H
⊢ b * a ∈ H

tactic: simp_all only [inv_mul_cancel_left, inv_inv]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
nH : H.Normal
a b : G
h : a * b ∈ H
this : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ H
⊢ b * a ∈ H
state_after: no goals
Theorem: Finset.Icc_erase_left
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: simp [← coe_inj]
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c : α
inst✝ : DecidableEq α
a b : α
⊢ (Icc a b).erase a = Ioc a b
state_after: no goals
Theorem: Ordinal.nhds_left'_eq_nhds_ne
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: rw [← nhds_left'_sup_nhds_right', nhds_right', sup_bot_eq]
state_before: s : Set Ordinal.{u}
a✝ : Ordinal.{u}
a : Ordinal.{u_1}
⊢ 𝓝[<] a = 𝓝[≠] a
state_after: no goals
Theorem: Multiset.count_eq_card
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [countP_eq_card, count, @eq_comm _ a]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
⊢ count a s = card s ↔ ∀ x ∈ s, a = x
state_after: no goals
Theorem: MonoidAlgebra.single_mul_apply_aux
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: classical exact
    have : (f.sum fun a b => ite (x * a = y) (0 * b) 0) = 0 := by simp
    calc
      (HMul.hMul (α := MonoidAlgebra k G) (single x r) f) y =
          sum f fun a b => ite (x * a = y) (r * b) 0 :=
        (mul_apply _ _ _).trans <| sum_single_index this
      _ = f.sum fun a b => ite (a = z) (r * b) 0 := by simp only [H]
      _ = if z ∈ f.support then r * f z else 0 := f.support.sum_ite_eq' _ _
      _ = _ := by split_ifs with h <;> simp at h <;> simp [h]
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
⊢ (single x r * f) y = r * f z
state_after: no goals

tactic: exact
have : (f.sum fun a b => ite (x * a = y) (0 * b) 0) = 0 := by simp
calc
(HMul.hMul (α := MonoidAlgebra k G) (single x r) f) y =
sum f fun a b => ite (x * a = y) (r * b) 0 :=
(mul_apply _ _ _).trans <| sum_single_index this
_ = f.sum fun a b => ite (a = z) (r * b) 0 := by simp only [H]
_ = if z ∈ f.support then r * f z else 0 := f.support.sum_ite_eq' _ _
_ = _ := by split_ifs with h <;> simp at h <;> simp [h]
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
⊢ (single x r * f) y = r * f z
state_after: no goals

tactic: simp
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
⊢ (sum f fun a b => if x * a = y then 0 * b else 0) = 0
state_after: no goals

tactic: simp only [H]
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
this : (sum f fun a b => if x * a = y then 0 * b else 0) = 0
⊢ (sum f fun a b => if x * a = y then r * b else 0) = sum f fun a b => if a = z then r * b else 0
state_after: no goals

tactic: split_ifs with h <;> simp at h <;> simp [h]
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
this : (sum f fun a b => if x * a = y then 0 * b else 0) = 0
⊢ (if z ∈ f.support then r * f z else 0) = r * f z
state_after: no goals
Theorem: Dense.interior_compl
File: Mathlib/Topology/Basic.lean

tactic: rwa [compl_compl]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h : Dense s
⊢ Dense sᶜᶜ
state_after: no goals
Theorem: List.tail_dedup
File: Mathlib/Data/List/Dedup.lean

tactic: by_cases ha : a ∈ l <;> simp [ha, List.dedup_cons_of_mem]
state_before: α : Type u
inst✝¹ : DecidableEq α
inst✝ : Inhabited α
l✝ : List α
a : α
l : List α
⊢ (a :: l).dedup.tail = if (a :: l).headI ∈ (a :: l).tail then (a :: l).tail.dedup.tail else (a :: l).tail.dedup
state_after: no goals
Theorem: ofAdd_list_prod
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: simp [ofAdd]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : AddMonoid α
s : List α
⊢ ofAdd s.sum = (List.map (⇑ofAdd) s).prod
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : AddMonoid α
s : List α
⊢ s.sum = s.prod

tactic: rfl
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : AddMonoid α
s : List α
⊢ s.sum = s.prod
state_after: no goals
Theorem: ENNReal.exists_pos_sum_of_countable
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: rcases exists_between (pos_iff_ne_zero.2 hε) with ⟨r, h0r, hrε⟩
state_before: α : Type u_1
β : Type u_2
ι✝ : Type u_3
ε : ℝ≥0∞
hε : ε ≠ 0
ι : Type u_4
inst✝ : Countable ι
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∑' (i : ι), ↑(ε' i) < ε
state_after: case intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ε : ℝ≥0∞
hε : ε ≠ 0
ι : Type u_4
inst✝ : Countable ι
r : ℝ≥0∞
h0r : 0 < r
hrε : r < ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∑' (i : ι), ↑(ε' i) < ε

tactic: rcases lt_iff_exists_coe.1 hrε with ⟨x, rfl, _⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ε : ℝ≥0∞
hε : ε ≠ 0
ι : Type u_4
inst✝ : Countable ι
r : ℝ≥0∞
h0r : 0 < r
hrε : r < ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∑' (i : ι), ↑(ε' i) < ε
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ε : ℝ≥0∞
hε : ε ≠ 0
ι : Type u_4
inst✝ : Countable ι
x : ℝ≥0
right✝ : ↑x < ε
h0r : 0 < ↑x
hrε : ↑x < ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∑' (i : ι), ↑(ε' i) < ε

tactic: rcases NNReal.exists_pos_sum_of_countable (coe_pos.1 h0r).ne' ι with ⟨ε', hp, c, hc, hcr⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ε : ℝ≥0∞
hε : ε ≠ 0
ι : Type u_4
inst✝ : Countable ι
x : ℝ≥0
right✝ : ↑x < ε
h0r : 0 < ↑x
hrε : ↑x < ε
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∑' (i : ι), ↑(ε' i) < ε
state_after: case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ε : ℝ≥0∞
hε : ε ≠ 0
ι : Type u_4
inst✝ : Countable ι
x : ℝ≥0
right✝ : ↑x < ε
h0r : 0 < ↑x
hrε : ↑x < ε
ε' : ι → ℝ≥0
hp : ∀ (i : ι), 0 < ε' i
c : ℝ≥0
hc : HasSum ε' c
hcr : c < x
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∑' (i : ι), ↑(ε' i) < ε

tactic: exact ⟨ε', hp, (ENNReal.tsum_coe_eq hc).symm ▸ lt_trans (coe_lt_coe.2 hcr) hrε⟩
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
ι✝ : Type u_3
ε : ℝ≥0∞
hε : ε ≠ 0
ι : Type u_4
inst✝ : Countable ι
x : ℝ≥0
right✝ : ↑x < ε
h0r : 0 < ↑x
hrε : ↑x < ε
ε' : ι → ℝ≥0
hp : ∀ (i : ι), 0 < ε' i
c : ℝ≥0
hc : HasSum ε' c
hcr : c < x
⊢ ∃ ε', (∀ (i : ι), 0 < ε' i) ∧ ∑' (i : ι), ↑(ε' i) < ε
state_after: no goals
Theorem: SemiNormedGrp.explicitCokernelIso_inv_π
File: Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean

tactic: simp [explicitCokernelπ, explicitCokernelIso]
state_before: X Y : SemiNormedGrp
f : X ⟶ Y
⊢ cokernel.π f ≫ (explicitCokernelIso f).inv = explicitCokernelπ f
state_after: no goals
Theorem: ProbabilityTheory.kernel.IsMarkovKernel.comapRight
File: Mathlib/Probability/Kernel/Basic.lean

tactic: refine ⟨fun a => ⟨?_⟩⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : ↥(kernel α β)
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
⊢ IsMarkovKernel (kernel.comapRight κ hf)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : ↥(kernel α β)
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ ((kernel.comapRight κ hf) a) Set.univ = 1

tactic: rw [comapRight_apply' κ hf a MeasurableSet.univ]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : ↥(kernel α β)
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ ((kernel.comapRight κ hf) a) Set.univ = 1
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : ↥(kernel α β)
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ (κ a) (f '' Set.univ) = 1

tactic: simp only [Set.image_univ, Subtype.range_coe_subtype, Set.setOf_mem_eq]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : ↥(kernel α β)
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ (κ a) (f '' Set.univ) = 1
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : ↥(kernel α β)
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ (κ a) (Set.range f) = 1

tactic: exact hκ a
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
γ : Type u_4
mγ : MeasurableSpace γ
f : γ → β
κ : ↥(kernel α β)
hf : MeasurableEmbedding f
hκ : ∀ (a : α), (κ a) (Set.range f) = 1
a : α
⊢ (κ a) (Set.range f) = 1
state_after: no goals
Theorem: CategoryTheory.InjectiveResolution.cocomplex_exactAt_succ
File: Mathlib/CategoryTheory/Preadditive/InjectiveResolution.lean

tactic: rw [← quasiIsoAt_iff_exactAt I.ι (n + 1) (exactAt_succ_single_obj _ _)]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
n : ℕ
⊢ ExactAt I.cocomplex (n + 1)
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
n : ℕ
⊢ QuasiIsoAt I.ι (n + 1)

tactic: infer_instance
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
Z : C
I : InjectiveResolution Z
n : ℕ
⊢ QuasiIsoAt I.ι (n + 1)
state_after: no goals
Theorem: Nat.mul_add_mod_of_lt
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [Nat.mul_add_mod', Nat.mod_eq_of_lt h]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : c < b
⊢ (a * b + c) % b = c
state_after: no goals
Theorem: one_sub_mul
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [sub_mul, one_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonAssocRing α
a b : α
⊢ (1 - a) * b = b - a * b
state_after: no goals
Theorem: WittVector.mapFun.pow
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: map_fun_tac
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : R →+* S
x y : 𝕎 R
n : ℕ
⊢ mapFun (⇑f) (x ^ n) = mapFun (⇑f) x ^ n
state_after: no goals
Theorem: PiNat.apply_firstDiff_ne
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: rw [firstDiff_def, dif_pos h]
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
h : x ≠ y
⊢ x (firstDiff x y) ≠ y (firstDiff x y)
state_after: E : ℕ → Type u_1
x y : (n : ℕ) → E n
h : x ≠ y
⊢ x (Nat.find ⋯) ≠ y (Nat.find ⋯)

tactic: exact Nat.find_spec (ne_iff.1 h)
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
h : x ≠ y
⊢ x (Nat.find ⋯) ≠ y (Nat.find ⋯)
state_after: no goals
Theorem: List.mem_range
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp only [range_eq_range', mem_range'_1, Nat.zero_le, true_and, Nat.zero_add]
state_before: m n : Nat
⊢ m ∈ range n ↔ m < n
state_after: no goals
Theorem: bernsteinApproximation.le_of_mem_S_compl
File: Mathlib/Analysis/SpecialFunctions/Bernstein.lean

tactic: simp only [Finset.mem_compl, not_lt, Set.mem_toFinset, Set.mem_setOf_eq, S] at m
state_before: f : C(↑I, ℝ)
ε : ℝ
h : 0 < ε
n : ℕ
x : ↑I
k : Fin (n + 1)
m : k ∈ (S f ε h n x)ᶜ
⊢ 1 ≤ δ f ε h ^ (-2) * (↑x - ↑k/ₙ) ^ 2
state_after: f : C(↑I, ℝ)
ε : ℝ
h : 0 < ε
n : ℕ
x : ↑I
k : Fin (n + 1)
m : δ f ε h ≤ dist k/ₙ x
⊢ 1 ≤ δ f ε h ^ (-2) * (↑x - ↑k/ₙ) ^ 2

tactic: rw [zpow_neg, ← div_eq_inv_mul, zpow_two, ← pow_two, one_le_div (pow_pos δ_pos 2), sq_le_sq,
  abs_of_pos δ_pos]
state_before: f : C(↑I, ℝ)
ε : ℝ
h : 0 < ε
n : ℕ
x : ↑I
k : Fin (n + 1)
m : δ f ε h ≤ dist k/ₙ x
⊢ 1 ≤ δ f ε h ^ (-2) * (↑x - ↑k/ₙ) ^ 2
state_after: f : C(↑I, ℝ)
ε : ℝ
h : 0 < ε
n : ℕ
x : ↑I
k : Fin (n + 1)
m : δ f ε h ≤ dist k/ₙ x
⊢ δ f ε h ≤ |↑x - ↑k/ₙ|

tactic: rwa [dist_comm] at m
state_before: f : C(↑I, ℝ)
ε : ℝ
h : 0 < ε
n : ℕ
x : ↑I
k : Fin (n + 1)
m : δ f ε h ≤ dist k/ₙ x
⊢ δ f ε h ≤ |↑x - ↑k/ₙ|
state_after: no goals
Theorem: Function.Embedding.enccard_le
File: Mathlib/Data/Set/Card.lean

tactic: rw [← encard_univ_coe, ← e.injective.encard_image, ← Subtype.coe_injective.encard_image]
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
e : ↑s ↪ ↑t
⊢ s.encard ≤ t.encard
state_after: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
e : ↑s ↪ ↑t
⊢ ((fun a => ↑a) '' (⇑e '' univ)).encard ≤ t.encard

tactic: exact encard_mono (by simp)
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
e : ↑s ↪ ↑t
⊢ ((fun a => ↑a) '' (⇑e '' univ)).encard ≤ t.encard
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s : Set α
t : Set β
f : α → β
e : ↑s ↪ ↑t
⊢ (fun a => ↑a) '' (⇑e '' univ) ≤ t
state_after: no goals
Theorem: Set.piecewise_le
File: Mathlib/Data/Set/Function.lean

tactic: simp [*]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ✝ : α → Sort u_6
s✝ : Set α
f g✝ : (i : α) → δ✝ i
inst✝² : (j : α) → Decidable (j ∈ s✝)
δ : α → Type u_7
inst✝¹ : (i : α) → Preorder (δ i)
s : Set α
inst✝ : (j : α) → Decidable (j ∈ s)
f₁ f₂ g : (i : α) → δ i
h₁ : ∀ i ∈ s, f₁ i ≤ g i
h₂ : ∀ i ∉ s, f₂ i ≤ g i
i : α
h : i ∈ s
⊢ s.piecewise f₁ f₂ i ≤ g i
state_after: no goals

tactic: simp [*]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ✝ : α → Sort u_6
s✝ : Set α
f g✝ : (i : α) → δ✝ i
inst✝² : (j : α) → Decidable (j ∈ s✝)
δ : α → Type u_7
inst✝¹ : (i : α) → Preorder (δ i)
s : Set α
inst✝ : (j : α) → Decidable (j ∈ s)
f₁ f₂ g : (i : α) → δ i
h₁ : ∀ i ∈ s, f₁ i ≤ g i
h₂ : ∀ i ∉ s, f₂ i ≤ g i
i : α
h : i ∉ s
⊢ s.piecewise f₁ f₂ i ≤ g i
state_after: no goals
Theorem: LieSubmodule.sup_coe_toSubmodule
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rfl
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ ↑(N ⊔ N') = ↑N ⊔ ↑N'
state_after: no goals
Theorem: List.sum_map_count_dedup_eq_length
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: simpa using sum_map_count_dedup_filter_eq_countP (fun _ => True) l
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : DecidableEq α
l : List α
⊢ (map (fun x => count x l) l.dedup).sum = l.length
state_after: no goals