1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: PicardLindelof.exists_solution
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: rcases v.exists_fixed with ⟨f, hf⟩
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
⊢ ∃ f, f ↑v.t₀ = v.x₀ ∧ ∀ t ∈ Icc v.tMin v.tMax, HasDerivWithinAt f (v.toFun t (f t)) (Icc v.tMin v.tMax) t
state_after: case intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
f : v.FunSpace
hf : f.next = f
⊢ ∃ f, f ↑v.t₀ = v.x₀ ∧ ∀ t ∈ Icc v.tMin v.tMax, HasDerivWithinAt f (v.toFun t (f t)) (Icc v.tMin v.tMax) t

tactic: refine ⟨f ∘ v.proj, ?_, fun t ht => ?_⟩
state_before: case intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
f : v.FunSpace
hf : f.next = f
⊢ ∃ f, f ↑v.t₀ = v.x₀ ∧ ∀ t ∈ Icc v.tMin v.tMax, HasDerivWithinAt f (v.toFun t (f t)) (Icc v.tMin v.tMax) t
state_after: case intro.refine_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
f : v.FunSpace
hf : f.next = f
⊢ (f.toFun ∘ v.proj) ↑v.t₀ = v.x₀

case intro.refine_2
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
f : v.FunSpace
hf : f.next = f
t : ℝ
ht : t ∈ Icc v.tMin v.tMax
⊢ HasDerivWithinAt (f.toFun ∘ v.proj) (v.toFun t ((f.toFun ∘ v.proj) t)) (Icc v.tMin v.tMax) t

tactic: lift t to Icc v.tMin v.tMax using ht
state_before: case intro.refine_2
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
f : v.FunSpace
hf : f.next = f
t : ℝ
ht : t ∈ Icc v.tMin v.tMax
⊢ HasDerivWithinAt (fun x => f.toFun (v.proj x)) (v.toFun t (f.toFun (v.proj t))) (Icc v.tMin v.tMax) t
state_after: case intro.refine_2.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
f : v.FunSpace
hf : f.next = f
t : { x // x ∈ Icc v.tMin v.tMax }
⊢ HasDerivWithinAt (fun x => f.toFun (v.proj x)) (v.toFun (↑t) (f.toFun (v.proj ↑t))) (Icc v.tMin v.tMax) ↑t

tactic: simpa only [hf, v.proj_coe] using f.hasDerivWithinAt_next t
state_before: case intro.refine_2.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
inst✝ : CompleteSpace E
f : v.FunSpace
hf : f.next = f
t : { x // x ∈ Icc v.tMin v.tMax }
⊢ HasDerivWithinAt (fun x => f.toFun (v.proj x)) (v.toFun (↑t) (f.toFun (v.proj ↑t))) (Icc v.tMin v.tMax) ↑t
state_after: no goals
Theorem: GeneralizedContinuedFraction.squashSeq_nth_of_lt
File: Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean

tactic: cases s_succ_nth_eq : s.get? (n + 1) with
| none => rw [squashSeq_eq_self_of_terminated s_succ_nth_eq]
| some =>
  obtain ⟨gp_n, s_nth_eq⟩ : ∃ gp_n, s.get? n = some gp_n :=
    s.ge_stable n.le_succ s_succ_nth_eq
  obtain ⟨gp_m, s_mth_eq⟩ : ∃ gp_m, s.get? m = some gp_m :=
    s.ge_stable (le_of_lt m_lt_n) s_nth_eq
  simp [*, squashSeq, m_lt_n.ne]
state_before: K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
m : ℕ
m_lt_n : m < n
⊢ (squashSeq s n).get? m = s.get? m
state_after: no goals

tactic: rw [squashSeq_eq_self_of_terminated s_succ_nth_eq]
state_before: case none
K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
m : ℕ
m_lt_n : m < n
s_succ_nth_eq : s.get? (n + 1) = none
⊢ (squashSeq s n).get? m = s.get? m
state_after: no goals

tactic: obtain ⟨gp_n, s_nth_eq⟩ : ∃ gp_n, s.get? n = some gp_n :=
  s.ge_stable n.le_succ s_succ_nth_eq
state_before: case some
K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
m : ℕ
m_lt_n : m < n
val✝ : Pair K
s_succ_nth_eq : s.get? (n + 1) = some val✝
⊢ (squashSeq s n).get? m = s.get? m
state_after: case some.intro
K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
m : ℕ
m_lt_n : m < n
val✝ : Pair K
s_succ_nth_eq : s.get? (n + 1) = some val✝
gp_n : Pair K
s_nth_eq : s.get? n = some gp_n
⊢ (squashSeq s n).get? m = s.get? m

tactic: obtain ⟨gp_m, s_mth_eq⟩ : ∃ gp_m, s.get? m = some gp_m :=
  s.ge_stable (le_of_lt m_lt_n) s_nth_eq
state_before: case some.intro
K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
m : ℕ
m_lt_n : m < n
val✝ : Pair K
s_succ_nth_eq : s.get? (n + 1) = some val✝
gp_n : Pair K
s_nth_eq : s.get? n = some gp_n
⊢ (squashSeq s n).get? m = s.get? m
state_after: case some.intro.intro
K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
m : ℕ
m_lt_n : m < n
val✝ : Pair K
s_succ_nth_eq : s.get? (n + 1) = some val✝
gp_n : Pair K
s_nth_eq : s.get? n = some gp_n
gp_m : Pair K
s_mth_eq : s.get? m = some gp_m
⊢ (squashSeq s n).get? m = s.get? m

tactic: simp [*, squashSeq, m_lt_n.ne]
state_before: case some.intro.intro
K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
m : ℕ
m_lt_n : m < n
val✝ : Pair K
s_succ_nth_eq : s.get? (n + 1) = some val✝
gp_n : Pair K
s_nth_eq : s.get? n = some gp_n
gp_m : Pair K
s_mth_eq : s.get? m = some gp_m
⊢ (squashSeq s n).get? m = s.get? m
state_after: no goals
Theorem: Subgroup.comap_injective_isCommutative
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: have := mul_comm (⟨f a, a.2⟩ : H) (⟨f b, b.2⟩ : H)
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
f : G' →* G
hf : Injective ⇑f
inst✝ : H.IsCommutative
a b : ↥(comap f H)
⊢ ↑(a * b) = ↑(b * a)
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
f : G' →* G
hf : Injective ⇑f
inst✝ : H.IsCommutative
a b : ↥(comap f H)
this : ⟨f ↑a, ⋯⟩ * ⟨f ↑b, ⋯⟩ = ⟨f ↑b, ⋯⟩ * ⟨f ↑a, ⋯⟩
⊢ ↑(a * b) = ↑(b * a)

tactic: rwa [Subtype.ext_iff, coe_mul, coe_mul, coe_mk, coe_mk, ← map_mul, ← map_mul,
  hf.eq_iff] at this
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
f : G' →* G
hf : Injective ⇑f
inst✝ : H.IsCommutative
a b : ↥(comap f H)
this : ⟨f ↑a, ⋯⟩ * ⟨f ↑b, ⋯⟩ = ⟨f ↑b, ⋯⟩ * ⟨f ↑a, ⋯⟩
⊢ ↑(a * b) = ↑(b * a)
state_after: no goals
Theorem: SimpleGraph.Walk.IsEulerian.mem_edges_iff
File: Mathlib/Combinatorics/SimpleGraph/Trails.lean

tactic: simpa [Nat.succ_le] using (h e he).ge
state_before: V : Type u_1
G : SimpleGraph V
inst✝ : DecidableEq V
u v : V
p : G.Walk u v
h : p.IsEulerian
e : Sym2 V
he : e ∈ G.edgeSet
⊢ e ∈ p.edges
state_after: no goals
Theorem: UniqueFactorizationMonoid.normalizedFactors_prod_of_prime
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simpa only [← Multiset.rel_eq, ← associated_eq_eq] using
  prime_factors_unique prime_of_normalized_factor h
    (normalizedFactors_prod (m.prod_ne_zero_of_prime h))
state_before: α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : NormalizationMonoid α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : Nontrivial α
inst✝ : Unique αˣ
m : Multiset α
h : ∀ p ∈ m, Prime p
⊢ normalizedFactors m.prod = m
state_after: no goals
Theorem: Filter.eventuallyConst_pred
File: Mathlib/Order/Filter/EventuallyConst.lean

tactic: simp [eventuallyConst_pred', or_comm, EventuallyEq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f : α → β
p : α → Prop
⊢ EventuallyConst p l ↔ (∀ᶠ (x : α) in l, p x) ∨ ∀ᶠ (x : α) in l, ¬p x
state_after: no goals
Theorem: Nat.count_lt_count_succ_iff
File: Mathlib/Data/Nat/Count.lean

tactic: by_cases h : p n <;> simp [count_succ, h]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n : ℕ
⊢ count p n < count p (n + 1) ↔ p n
state_after: no goals
Theorem: ProbabilityTheory.kernel.withDensity_rnDeriv_eq_zero_iff_apply_eq_zero
File: Mathlib/Probability/Kernel/RadonNikodym.lean

tactic: rw [← Measure.measure_univ_eq_zero]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ (withDensity η (rnDeriv κ η)) a = 0 ↔ ((withDensity η (rnDeriv κ η)) a) (mutuallySingularSetSlice κ η a)ᶜ = 0
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ ((withDensity η (rnDeriv κ η)) a) univ = 0 ↔ ((withDensity η (rnDeriv κ η)) a) (mutuallySingularSetSlice κ η a)ᶜ = 0

tactic: have : univ = (mutuallySingularSetSlice κ η a) ∪ (mutuallySingularSetSlice κ η a)ᶜ := by simp
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ ((withDensity η (rnDeriv κ η)) a) univ = 0 ↔ ((withDensity η (rnDeriv κ η)) a) (mutuallySingularSetSlice κ η a)ᶜ = 0
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
this : univ = mutuallySingularSetSlice κ η a ∪ (mutuallySingularSetSlice κ η a)ᶜ
⊢ ((withDensity η (rnDeriv κ η)) a) univ = 0 ↔ ((withDensity η (rnDeriv κ η)) a) (mutuallySingularSetSlice κ η a)ᶜ = 0

tactic: rw [this, measure_union disjoint_compl_right (measurableSet_mutuallySingularSetSlice κ η a).compl,
  withDensity_rnDeriv_mutuallySingularSetSlice, zero_add]
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
this : univ = mutuallySingularSetSlice κ η a ∪ (mutuallySingularSetSlice κ η a)ᶜ
⊢ ((withDensity η (rnDeriv κ η)) a) univ = 0 ↔ ((withDensity η (rnDeriv κ η)) a) (mutuallySingularSetSlice κ η a)ᶜ = 0
state_after: no goals

tactic: simp
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : ↥(kernel α γ)
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : ↥(kernel α γ)
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel η
a : α
⊢ univ = mutuallySingularSetSlice κ η a ∪ (mutuallySingularSetSlice κ η a)ᶜ
state_after: no goals
Theorem: Std.Range.numElems_step_1
File: .lake/packages/batteries/Batteries/Data/Range/Lemmas.lean

tactic: simp [numElems]
state_before: start stop : Nat
⊢ { start := start, stop := stop, step := 1 }.numElems = stop - start
state_after: no goals
Theorem: Num.add_succ
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp [zero_add]
state_before: α : Type u_1
n : Num
⊢ 0 + n.succ = (0 + n).succ
state_after: no goals

tactic: rw [PosNum.add_one, add_zero, succ, succ']
state_before: α : Type u_1
p : PosNum
⊢ pos (p + 1) = (pos p + 0).succ
state_after: no goals
Theorem: CategoryTheory.Limits.diagonalObjPullbackFstIso_hom_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta diagonalObjPullbackFstIso
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (diagonalObjPullbackFstIso f g).hom ≫ snd = fst ≫ fst
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g fst ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst ≫ g) ≪≫ congrHom ⋯ ⋯).hom ≫
      snd =
    fst ≫ fst

tactic: simp
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g fst ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst ≫ g) ≪≫ congrHom ⋯ ⋯).hom ≫
      snd =
    fst ≫ fst
state_after: no goals
Theorem: ArithmeticFunction.moebius_eq_or
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp only [moebius, coe_mk]
state_before: R : Type u_1
n : ℕ
⊢ μ n = 0 ∨ μ n = 1 ∨ μ n = -1
state_after: R : Type u_1
n : ℕ
⊢ (if Squarefree n then (-1) ^ Ω n else 0) = 0 ∨
    (if Squarefree n then (-1) ^ Ω n else 0) = 1 ∨ (if Squarefree n then (-1) ^ Ω n else 0) = -1

tactic: split_ifs
state_before: R : Type u_1
n : ℕ
⊢ (if Squarefree n then (-1) ^ Ω n else 0) = 0 ∨
    (if Squarefree n then (-1) ^ Ω n else 0) = 1 ∨ (if Squarefree n then (-1) ^ Ω n else 0) = -1
state_after: case pos
R : Type u_1
n : ℕ
h✝ : Squarefree n
⊢ (-1) ^ Ω n = 0 ∨ (-1) ^ Ω n = 1 ∨ (-1) ^ Ω n = -1

case neg
R : Type u_1
n : ℕ
h✝ : ¬Squarefree n
⊢ 0 = 0 ∨ 0 = 1 ∨ False

tactic: right
state_before: case pos
R : Type u_1
n : ℕ
h✝ : Squarefree n
⊢ (-1) ^ Ω n = 0 ∨ (-1) ^ Ω n = 1 ∨ (-1) ^ Ω n = -1
state_after: case pos.h
R : Type u_1
n : ℕ
h✝ : Squarefree n
⊢ (-1) ^ Ω n = 1 ∨ (-1) ^ Ω n = -1

tactic: exact neg_one_pow_eq_or ..
state_before: case pos.h
R : Type u_1
n : ℕ
h✝ : Squarefree n
⊢ (-1) ^ Ω n = 1 ∨ (-1) ^ Ω n = -1
state_after: no goals

tactic: left
state_before: case neg
R : Type u_1
n : ℕ
h✝ : ¬Squarefree n
⊢ 0 = 0 ∨ 0 = 1 ∨ False
state_after: case neg.h
R : Type u_1
n : ℕ
h✝ : ¬Squarefree n
⊢ 0 = 0

tactic: rfl
state_before: case neg.h
R : Type u_1
n : ℕ
h✝ : ¬Squarefree n
⊢ 0 = 0
state_after: no goals
Theorem: CategoryTheory.Limits.inl_pushoutZeroZeroIso_inv
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: simp [Iso.comp_inv_eq]
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ coprod.inl ≫ (pushoutZeroZeroIso X Y).inv = pushout.inl
state_after: no goals
Theorem: List.nil_subperm
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: simp
state_before: α : Type u_1
l : List α
⊢ [] <+ l
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso_inv_naturality
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: simp only [← cancel_mono h₂.homologyIso.hom, assoc, Iso.inv_hom_id_assoc, comp_id,
  ← RightHomologyData.rightHomologyIso_hom_naturality φ h₁ h₂, Iso.inv_hom_id]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
⊢ h₁.homologyIso.inv ≫ homologyMap φ = rightHomologyMap' φ h₁ h₂ ≫ h₂.homologyIso.inv
state_after: no goals
Theorem: Submonoid.isOfFinOrder_coe
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [isOfFinOrder_iff_pow_eq_one, isOfFinOrder_iff_pow_eq_one]
state_before: G : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n m : ℕ
H : Submonoid G
x : ↥H
⊢ IsOfFinOrder ↑x ↔ IsOfFinOrder x
state_after: G : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n m : ℕ
H : Submonoid G
x : ↥H
⊢ (∃ n, 0 < n ∧ ↑x ^ n = 1) ↔ ∃ n, 0 < n ∧ x ^ n = 1

tactic: norm_cast
state_before: G : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n m : ℕ
H : Submonoid G
x : ↥H
⊢ (∃ n, 0 < n ∧ ↑x ^ n = 1) ↔ ∃ n, 0 < n ∧ x ^ n = 1
state_after: no goals
Theorem: MeasureTheory.pdf.uniformPDF_eq_pdf
File: Mathlib/Probability/Distributions/Uniform.lean

tactic: unfold uniformPDF
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hs : MeasurableSet s
hu : IsUniform X s ℙ μ
⊢ (fun x => uniformPDF s x μ) =ᶠ[ae μ] pdf X ℙ μ
state_after: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hs : MeasurableSet s
hu : IsUniform X s ℙ μ
⊢ (fun x => s.indicator ((μ s)⁻¹ • 1) x) =ᶠ[ae μ] pdf X ℙ μ

tactic: exact Filter.EventuallyEq.trans (pdf.IsUniform.pdf_eq hs hu).symm (ae_eq_refl _)
state_before: E : Type u_1
inst✝ : MeasurableSpace E
m μ : Measure E
Ω : Type u_2
x✝ : MeasurableSpace Ω
ℙ : Measure Ω
X : Ω → E
s : Set E
hs : MeasurableSet s
hu : IsUniform X s ℙ μ
⊢ (fun x => s.indicator ((μ s)⁻¹ • 1) x) =ᶠ[ae μ] pdf X ℙ μ
state_after: no goals
Theorem: NNReal.mul_iInf
File: Mathlib/Data/NNReal/Basic.lean

tactic: simpa only [mul_comm] using iInf_mul f a
state_before: ι : Sort u_1
f✝ f : ι → ℝ≥0
a : ℝ≥0
⊢ a * iInf f = ⨅ i, a * f i
state_after: no goals
Theorem: List.ofFn_getElem
File: Mathlib/Data/List/OfFn.lean

tactic: rw [ofFn_zero]
state_before: α : Type u
⊢ (ofFn fun i => [][↑i]) = []
state_after: no goals

tactic: rw [ofFn_succ]
state_before: α : Type u
a : α
l : List α
⊢ (ofFn fun i => (a :: l)[↑i]) = a :: l
state_after: α : Type u
a : α
l : List α
⊢ ((a :: l)[↑0] :: ofFn fun i => (a :: l)[↑i.succ]) = a :: l

tactic: congr
state_before: α : Type u
a : α
l : List α
⊢ ((a :: l)[↑0] :: ofFn fun i => (a :: l)[↑i.succ]) = a :: l
state_after: case e_tail
α : Type u
a : α
l : List α
⊢ (ofFn fun i => (a :: l)[↑i.succ]) = l

tactic: exact ofFn_get l
state_before: case e_tail
α : Type u
a : α
l : List α
⊢ (ofFn fun i => (a :: l)[↑i.succ]) = l
state_after: no goals
Theorem: Ring.eq_mul_inverse_iff_mul_eq
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [h1, inverse_mul_cancel_right _ _ h]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x y z : M₀
h : IsUnit z
h1 : x = y * inverse z
⊢ x * z = y
state_after: no goals

tactic: rw [← h1, mul_inverse_cancel_right _ _ h]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x y z : M₀
h : IsUnit z
h1 : x * z = y
⊢ x = y * inverse z
state_after: no goals
Theorem: List.formPerm_apply_getElem_zero
File: Mathlib/GroupTheory/Perm/List.lean

tactic: rcases l with (_ | ⟨x, _ | ⟨y, tl⟩⟩)
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
hl : 1 < l.length
⊢ l.formPerm l[0] = l[1]
state_after: case nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
h : [].Nodup
hl : 1 < [].length
⊢ [].formPerm [][0] = [][1]

case cons.nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x : α
h : [x].Nodup
hl : 1 < [x].length
⊢ [x].formPerm [x][0] = [x][1]

case cons.cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x y : α
tl : List α
h : (x :: y :: tl).Nodup
hl : 1 < (x :: y :: tl).length
⊢ (x :: y :: tl).formPerm (x :: y :: tl)[0] = (x :: y :: tl)[1]

tactic: simp at hl
state_before: case nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
h : [].Nodup
hl : 1 < [].length
⊢ [].formPerm [][0] = [][1]
state_after: no goals

tactic: simp at hl
state_before: case cons.nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x : α
h : [x].Nodup
hl : 1 < [x].length
⊢ [x].formPerm [x][0] = [x][1]
state_after: no goals

tactic: rw [getElem_cons_zero, formPerm_apply_head _ _ _ h]
state_before: case cons.cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x y : α
tl : List α
h : (x :: y :: tl).Nodup
hl : 1 < (x :: y :: tl).length
⊢ (x :: y :: tl).formPerm (x :: y :: tl)[0] = (x :: y :: tl)[1]
state_after: case cons.cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x y : α
tl : List α
h : (x :: y :: tl).Nodup
hl : 1 < (x :: y :: tl).length
⊢ y = (x :: y :: tl)[1]

tactic: rfl
state_before: case cons.cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x y : α
tl : List α
h : (x :: y :: tl).Nodup
hl : 1 < (x :: y :: tl).length
⊢ y = (x :: y :: tl)[1]
state_after: no goals
Theorem: iSup_pair
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iSup_insert, iSup_singleton]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a✝ b✝ : α
f : β → α
a b : β
⊢ ⨆ x ∈ {a, b}, f x = f a ⊔ f b
state_after: no goals
Theorem: dist_midpoint_left
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: rw [dist_comm, dist_left_midpoint]
state_before: α : Type u_1
V : Type u_2
P : Type u_3
W : Type u_4
Q : Type u_5
inst✝⁹ : SeminormedAddCommGroup V
inst✝⁸ : PseudoMetricSpace P
inst✝⁷ : NormedAddTorsor V P
inst✝⁶ : NormedAddCommGroup W
inst✝⁵ : MetricSpace Q
inst✝⁴ : NormedAddTorsor W Q
𝕜 : Type u_6
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : Invertible 2
p₁ p₂ : P
⊢ dist (midpoint 𝕜 p₁ p₂) p₁ = ‖2‖⁻¹ * dist p₁ p₂
state_after: no goals
Theorem: List.get_rotate
File: Mathlib/Data/List/Rotate.lean

tactic: simp [getElem_rotate]
state_before: α : Type u
l : List α
n : ℕ
k : Fin (l.rotate n).length
⊢ (l.rotate n).get k = l.get ⟨(↑k + n) % l.length, ⋯⟩
state_after: no goals
Theorem: Nat.add_choose_eq
File: Mathlib/Data/Nat/Choose/Vandermonde.lean

tactic: calc
  (m + n).choose k = ((X + 1) ^ (m + n)).coeff k := by rw [coeff_X_add_one_pow, Nat.cast_id]
  _ = ((X + 1) ^ m * (X + 1) ^ n).coeff k := by rw [pow_add]
  _ = ∑ ij ∈ antidiagonal k, m.choose ij.1 * n.choose ij.2 := by
    rw [coeff_mul, Finset.sum_congr rfl]
    simp only [coeff_X_add_one_pow, Nat.cast_id, eq_self_iff_true, imp_true_iff]
state_before: m n k : ℕ
⊢ (m + n).choose k = ∑ ij ∈ antidiagonal k, m.choose ij.1 * n.choose ij.2
state_after: no goals

tactic: rw [coeff_X_add_one_pow, Nat.cast_id]
state_before: m n k : ℕ
⊢ (m + n).choose k = ((X + 1) ^ (m + n)).coeff k
state_after: no goals

tactic: rw [pow_add]
state_before: m n k : ℕ
⊢ ((X + 1) ^ (m + n)).coeff k = ((X + 1) ^ m * (X + 1) ^ n).coeff k
state_after: no goals

tactic: rw [coeff_mul, Finset.sum_congr rfl]
state_before: m n k : ℕ
⊢ ((X + 1) ^ m * (X + 1) ^ n).coeff k = ∑ ij ∈ antidiagonal k, m.choose ij.1 * n.choose ij.2
state_after: m n k : ℕ
⊢ ∀ x ∈ antidiagonal k, ((X + 1) ^ m).coeff x.1 * ((X + 1) ^ n).coeff x.2 = m.choose x.1 * n.choose x.2

tactic: simp only [coeff_X_add_one_pow, Nat.cast_id, eq_self_iff_true, imp_true_iff]
state_before: m n k : ℕ
⊢ ∀ x ∈ antidiagonal k, ((X + 1) ^ m).coeff x.1 * ((X + 1) ^ n).coeff x.2 = m.choose x.1 * n.choose x.2
state_after: no goals
Theorem: fderiv_inv
File: Mathlib/Analysis/Calculus/Deriv/Inv.lean

tactic: rw [← deriv_fderiv, deriv_inv]
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 𝕜
⊢ fderiv 𝕜 (fun x => x⁻¹) x = smulRight 1 (-(x ^ 2)⁻¹)
state_after: no goals
Theorem: AddMonoidAlgebra.prod_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [prod_cons has, ih, single_mul_single, sum_cons has, prod_cons has]
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
ι : Type ui
inst✝¹ : CommSemiring k
inst✝ : AddCommMonoid G
s✝ : Finset ι
a✝ : ι → G
b : ι → k
a : ι
s : Finset ι
has : a ∉ s
ih : ∏ i ∈ s, single (a✝ i) (b i) = single (∑ i ∈ s, a✝ i) (∏ i ∈ s, b i)
⊢ ∏ i ∈ Finset.cons a s has, single (a✝ i) (b i) =
    single (∑ i ∈ Finset.cons a s has, a✝ i) (∏ i ∈ Finset.cons a s has, b i)
state_after: no goals