1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Primrec.pair
File: Mathlib/Computability/Primrec.lean

tactic: cases @decode α _ n <;> simp [encodek]
state_before: α✝ : Type u_1
σ : Type u_2
inst✝⁴ : Primcodable α✝
inst✝³ : Primcodable σ
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable γ
f : α → β
g : α → γ
hf : Primrec f
hg : Primrec g
n : ℕ
⊢ (Nat.casesOn (encode (decode n)) 0 fun n =>
      (Nat.pair (encode (Option.map f (decode n))).pred (encode (Option.map g (decode n))).pred).succ) =
    encode (Option.map (fun a => (f a, g a)) (decode n))
state_after: no goals
Theorem: Polynomial.mirror_natTrailingDegree
File: Mathlib/Algebra/Polynomial/Mirror.lean

tactic: by_cases hp : p = 0
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
⊢ p.mirror.natTrailingDegree = p.natTrailingDegree
state_after: case pos
R : Type u_1
inst✝ : Semiring R
p q : R[X]
hp : p = 0
⊢ p.mirror.natTrailingDegree = p.natTrailingDegree

case neg
R : Type u_1
inst✝ : Semiring R
p q : R[X]
hp : ¬p = 0
⊢ p.mirror.natTrailingDegree = p.natTrailingDegree

tactic: rw [hp, mirror_zero]
state_before: case pos
R : Type u_1
inst✝ : Semiring R
p q : R[X]
hp : p = 0
⊢ p.mirror.natTrailingDegree = p.natTrailingDegree
state_after: no goals

tactic: rw [mirror, natTrailingDegree_mul_X_pow ((mt reverse_eq_zero.mp) hp),
  natTrailingDegree_reverse, zero_add]
state_before: case neg
R : Type u_1
inst✝ : Semiring R
p q : R[X]
hp : ¬p = 0
⊢ p.mirror.natTrailingDegree = p.natTrailingDegree
state_after: no goals
Theorem: Ordinal.nmul_le_iff
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [← not_iff_not]
state_before: a b c d : Ordinal.{u}
⊢ a ⨳ b ≤ c ↔ ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'
state_after: a b c d : Ordinal.{u}
⊢ ¬a ⨳ b ≤ c ↔ ¬∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'

tactic: simp [lt_nmul_iff]
state_before: a b c d : Ordinal.{u}
⊢ ¬a ⨳ b ≤ c ↔ ¬∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'
state_after: no goals
Theorem: IntermediateField.normalClosure_mono
File: Mathlib/FieldTheory/NormalClosure.lean

tactic: rw [normalClosure_def', normalClosure_def']
state_before: F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
h : K ≤ K'
⊢ normalClosure F (↥K) L ≤ normalClosure F (↥K') L
state_after: F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
h : K ≤ K'
⊢ ⨆ f, map f K ≤ ⨆ f, map f K'

tactic: exact iSup_mono (fun f ↦ map_mono f h)
state_before: F : Type u_1
K✝ : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K✝
inst✝³ : Field L
inst✝² : Algebra F K✝
inst✝¹ : Algebra F L
K K' : IntermediateField F L
inst✝ : Normal F L
h : K ≤ K'
⊢ ⨆ f, map f K ≤ ⨆ f, map f K'
state_after: no goals
Theorem: IsExposed.inter_right
File: Mathlib/Analysis/Convex/Exposed.lean

tactic: rw [inter_comm]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 B C
hCA : C ⊆ A
⊢ IsExposed 𝕜 (A ∩ B) C
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 B C
hCA : C ⊆ A
⊢ IsExposed 𝕜 (B ∩ A) C

tactic: exact hC.inter_left hCA
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 B C
hCA : C ⊆ A
⊢ IsExposed 𝕜 (B ∩ A) C
state_after: no goals
Theorem: Int.pairwise_one_le_dist
File: Mathlib/Topology/Instances/Int.lean

tactic: intro m n hne
state_before: ⊢ Pairwise fun m n => 1 ≤ dist m n
state_after: m n : ℤ
hne : m ≠ n
⊢ 1 ≤ dist m n

tactic: rw [dist_eq]
state_before: m n : ℤ
hne : m ≠ n
⊢ 1 ≤ dist m n
state_after: m n : ℤ
hne : m ≠ n
⊢ 1 ≤ |↑m - ↑n|

tactic: norm_cast
state_before: m n : ℤ
hne : m ≠ n
⊢ 1 ≤ |↑m - ↑n|
state_after: m n : ℤ
hne : m ≠ n
⊢ 1 ≤ |m - n|

tactic: rwa [← zero_add (1 : ℤ), Int.add_one_le_iff, abs_pos, sub_ne_zero]
state_before: m n : ℤ
hne : m ≠ n
⊢ 1 ≤ |m - n|
state_after: no goals
Theorem: MeasureTheory.SignedMeasure.mutuallySingular_singularPart
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

tactic: rw [mutuallySingular_ennreal_iff, singularPart_totalVariation,
  VectorMeasure.ennrealToMeasure_toENNRealVectorMeasure]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ s.singularPart μ ⟂ᵥ μ.toENNRealVectorMeasure
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ s.toJordanDecomposition.posPart.singularPart μ + s.toJordanDecomposition.negPart.singularPart μ ⟂ₘ μ

tactic: exact (mutuallySingular_singularPart _ _).add_left (mutuallySingular_singularPart _ _)
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s : SignedMeasure α
μ : Measure α
⊢ s.toJordanDecomposition.posPart.singularPart μ + s.toJordanDecomposition.negPart.singularPart μ ⟂ₘ μ
state_after: no goals
Theorem: Finset.prod_mul_prod_comm
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: simp_rw [prod_mul_distrib, mul_mul_mul_comm]
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✝ : CommMonoid β
f g h i : α → β
⊢ (∏ a ∈ s, f a * g a) * ∏ a ∈ s, h a * i a = (∏ a ∈ s, f a * h a) * ∏ a ∈ s, g a * i a
state_after: no goals
Theorem: Filter.comap_inf_principal_neBot_of_image_mem
File: Mathlib/Order/Filter/Basic.lean

tactic: refine ⟨compl_compl s ▸ mt mem_of_eq_bot ?_⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter β
m : α → β
hf : f.NeBot
s : Set α
hs : m '' s ∈ f
⊢ (comap m f ⊓ 𝓟 s).NeBot
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter β
m : α → β
hf : f.NeBot
s : Set α
hs : m '' s ∈ f
⊢ sᶜ ∉ comap m f

tactic: rintro ⟨t, ht, hts⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter β
m : α → β
hf : f.NeBot
s : Set α
hs : m '' s ∈ f
⊢ sᶜ ∉ comap m f
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
f : Filter β
m : α → β
hf : f.NeBot
s : Set α
hs : m '' s ∈ f
t : Set β
ht : t ∈ f
hts : m ⁻¹' t ⊆ sᶜ
⊢ False

tactic: rcases hf.nonempty_of_mem (inter_mem hs ht) with ⟨_, ⟨x, hxs, rfl⟩, hxt⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
f : Filter β
m : α → β
hf : f.NeBot
s : Set α
hs : m '' s ∈ f
t : Set β
ht : t ∈ f
hts : m ⁻¹' t ⊆ sᶜ
⊢ False
state_after: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
f : Filter β
m : α → β
hf : f.NeBot
s : Set α
hs : m '' s ∈ f
t : Set β
ht : t ∈ f
hts : m ⁻¹' t ⊆ sᶜ
x : α
hxs : x ∈ s
hxt : m x ∈ t
⊢ False

tactic: exact absurd hxs (hts hxt)
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
f : Filter β
m : α → β
hf : f.NeBot
s : Set α
hs : m '' s ∈ f
t : Set β
ht : t ∈ f
hts : m ⁻¹' t ⊆ sᶜ
x : α
hxs : x ∈ s
hxt : m x ∈ t
⊢ False
state_after: no goals
Theorem: Prop.compl_singleton
File: Mathlib/Data/Set/Basic.lean

tactic: simpa [@Iff.comm q] using not_iff
state_before: α : Type u_1
β : Type u_2
s t u : Set α
f : α → β
p q : Prop
⊢ q ∈ {p}ᶜ ↔ q ∈ {¬p}
state_after: no goals
Theorem: Nat.iSup_lt_succ
File: Mathlib/Data/Nat/Lattice.lean

tactic: simp [Nat.lt_succ_iff_lt_or_eq, iSup_or, iSup_sup_eq]
state_before: α : Type u_1
inst✝ : CompleteLattice α
u : ℕ → α
n : ℕ
⊢ ⨆ k, ⨆ (_ : k < n + 1), u k = (⨆ k, ⨆ (_ : k < n), u k) ⊔ u n
state_after: no goals
Theorem: zpow_add_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp only [← Int.ofNat_succ, zpow_natCast, pow_succ]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (↑n + 1) = a ^ ↑n * a
state_after: no goals

tactic: simp [Int.negSucc_eq', Int.add_left_neg]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n : ℤ
a : G
⊢ a ^ (Int.negSucc 0 + 1) = a ^ Int.negSucc 0 * a
state_after: no goals

tactic: rw [zpow_negSucc, pow_succ', mul_inv_rev, inv_mul_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (Int.negSucc (n + 1) + 1) = a ^ Int.negSucc (n + 1) * a
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (Int.negSucc (n + 1) + 1) = (a ^ (n + 1))⁻¹

tactic: rw [Int.negSucc_eq, Int.neg_add, Int.neg_add_cancel_right]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (Int.negSucc (n + 1) + 1) = (a ^ (n + 1))⁻¹
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (-↑(n + 1)) = (a ^ (n + 1))⁻¹

tactic: exact zpow_negSucc _ _
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℕ
⊢ a ^ (-↑(n + 1)) = (a ^ (n + 1))⁻¹
state_after: no goals
Theorem: List.ofFn_add
File: Mathlib/Data/List/OfFn.lean

tactic: induction' n with n IH
state_before: α : Type u
m n : ℕ
f : Fin (m + n) → α
⊢ ofFn f = (ofFn fun i => f (Fin.castAdd n i)) ++ ofFn fun j => f (Fin.natAdd m j)
state_after: case zero
α : Type u
m : ℕ
f : Fin (m + 0) → α
⊢ ofFn f = (ofFn fun i => f (Fin.castAdd 0 i)) ++ ofFn fun j => f (Fin.natAdd m j)

case succ
α : Type u
m n : ℕ
IH : ∀ (f : Fin (m + n) → α), ofFn f = (ofFn fun i => f (Fin.castAdd n i)) ++ ofFn fun j => f (Fin.natAdd m j)
f : Fin (m + (n + 1)) → α
⊢ ofFn f = (ofFn fun i => f (Fin.castAdd (n + 1) i)) ++ ofFn fun j => f (Fin.natAdd m j)

tactic: rw [ofFn_zero, append_nil, Fin.castAdd_zero, Fin.cast_refl]
state_before: case zero
α : Type u
m : ℕ
f : Fin (m + 0) → α
⊢ ofFn f = (ofFn fun i => f (Fin.castAdd 0 i)) ++ ofFn fun j => f (Fin.natAdd m j)
state_after: case zero
α : Type u
m : ℕ
f : Fin (m + 0) → α
⊢ ofFn f = ofFn fun i => f (id i)

tactic: rfl
state_before: case zero
α : Type u
m : ℕ
f : Fin (m + 0) → α
⊢ ofFn f = ofFn fun i => f (id i)
state_after: no goals

tactic: rw [ofFn_succ', ofFn_succ', IH, append_concat]
state_before: case succ
α : Type u
m n : ℕ
IH : ∀ (f : Fin (m + n) → α), ofFn f = (ofFn fun i => f (Fin.castAdd n i)) ++ ofFn fun j => f (Fin.natAdd m j)
f : Fin (m + (n + 1)) → α
⊢ ofFn f = (ofFn fun i => f (Fin.castAdd (n + 1) i)) ++ ofFn fun j => f (Fin.natAdd m j)
state_after: case succ
α : Type u
m n : ℕ
IH : ∀ (f : Fin (m + n) → α), ofFn f = (ofFn fun i => f (Fin.castAdd n i)) ++ ofFn fun j => f (Fin.natAdd m j)
f : Fin (m + (n + 1)) → α
⊢ ((ofFn fun i => f (Fin.castAdd n i).castSucc) ++ ofFn fun j => f (Fin.natAdd m j).castSucc).concat
      (f (Fin.last (m.add n))) =
    ((ofFn fun i => f (Fin.castAdd (n + 1) i)) ++ ofFn fun i => f (Fin.natAdd m i.castSucc)).concat
      (f (Fin.natAdd m (Fin.last n)))

tactic: rfl
state_before: case succ
α : Type u
m n : ℕ
IH : ∀ (f : Fin (m + n) → α), ofFn f = (ofFn fun i => f (Fin.castAdd n i)) ++ ofFn fun j => f (Fin.natAdd m j)
f : Fin (m + (n + 1)) → α
⊢ ((ofFn fun i => f (Fin.castAdd n i).castSucc) ++ ofFn fun j => f (Fin.natAdd m j).castSucc).concat
      (f (Fin.last (m.add n))) =
    ((ofFn fun i => f (Fin.castAdd (n + 1) i)) ++ ofFn fun i => f (Fin.natAdd m i.castSucc)).concat
      (f (Fin.natAdd m (Fin.last n)))
state_after: no goals
Theorem: CategoryTheory.Limits.biproduct.isoProduct_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: simp [Iso.inv_comp_eq]
state_before: J : Type w
K : Type u_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ (isoProduct f).inv ≫ π f j = lift (Pi.π f) ≫ π f j
state_after: no goals
Theorem: MonoidHom.comp_noncommCoprod
File: Mathlib/GroupTheory/NoncommCoprod.lean

tactic: simp
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : Monoid P
f : M →* P
g : N →* P
comm : ∀ (m : M) (n : N), Commute (f m) (g n)
Q : Type u_4
inst✝ : Monoid Q
h : P →* Q
x : M × N
⊢ (h.comp (f.noncommCoprod g comm)) x = ((h.comp f).noncommCoprod (h.comp g) ⋯) x
state_after: no goals
Theorem: Real.hasPDF_iff_of_aemeasurable
File: Mathlib/Probability/Density.lean

tactic: rw [hasPDF_iff_of_aemeasurable hX]
state_before: Ω : Type u_1
E : Type u_2
inst✝¹ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : AEMeasurable X ℙ
⊢ HasPDF X ℙ volume ↔ map X ℙ ≪ volume
state_after: Ω : Type u_1
E : Type u_2
inst✝¹ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : AEMeasurable X ℙ
⊢ (map X ℙ).HaveLebesgueDecomposition volume ∧ map X ℙ ≪ volume ↔ map X ℙ ≪ volume

tactic: exact and_iff_right inferInstance
state_before: Ω : Type u_1
E : Type u_2
inst✝¹ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : AEMeasurable X ℙ
⊢ (map X ℙ).HaveLebesgueDecomposition volume ∧ map X ℙ ≪ volume ↔ map X ℙ ≪ volume
state_after: no goals
Theorem: CochainComplex.mappingCone.inr_snd_assoc
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

tactic: simp only [← he, zero_add]
state_before: C : Type u_1
inst✝² : Category.{?u.47635, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
d e : ℤ
γ : Cochain G K d
he : 0 + d = e
⊢ 0 + e = d
state_after: no goals

tactic: obtain rfl : d = e := by omega
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
d e : ℤ
γ : Cochain G K d
he : 0 + d = e
⊢ (Cochain.ofHom (inr φ)).comp ((snd φ).comp γ he) ⋯ = γ
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
d : ℤ
γ : Cochain G K d
he : 0 + d = d
⊢ (Cochain.ofHom (inr φ)).comp ((snd φ).comp γ he) ⋯ = γ

tactic: rw [← Cochain.comp_assoc_of_first_is_zero_cochain, inr_snd, Cochain.id_comp]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
d : ℤ
γ : Cochain G K d
he : 0 + d = d
⊢ (Cochain.ofHom (inr φ)).comp ((snd φ).comp γ he) ⋯ = γ
state_after: no goals

tactic: omega
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
d e : ℤ
γ : Cochain G K d
he : 0 + d = e
⊢ d = e
state_after: no goals
Theorem: Pell.Solution₁.x_zpow_pos
File: Mathlib/NumberTheory/Pell.lean

tactic: cases n with
| ofNat n =>
  rw [Int.ofNat_eq_coe, zpow_natCast]
  exact x_pow_pos hax n
| negSucc n =>
  rw [zpow_negSucc]
  exact x_pow_pos hax (n + 1)
state_before: d : ℤ
a : Solution₁ d
hax : 0 < a.x
n : ℤ
⊢ 0 < (a ^ n).x
state_after: no goals

tactic: rw [Int.ofNat_eq_coe, zpow_natCast]
state_before: case ofNat
d : ℤ
a : Solution₁ d
hax : 0 < a.x
n : ℕ
⊢ 0 < (a ^ Int.ofNat n).x
state_after: case ofNat
d : ℤ
a : Solution₁ d
hax : 0 < a.x
n : ℕ
⊢ 0 < (a ^ n).x

tactic: exact x_pow_pos hax n
state_before: case ofNat
d : ℤ
a : Solution₁ d
hax : 0 < a.x
n : ℕ
⊢ 0 < (a ^ n).x
state_after: no goals

tactic: rw [zpow_negSucc]
state_before: case negSucc
d : ℤ
a : Solution₁ d
hax : 0 < a.x
n : ℕ
⊢ 0 < (a ^ Int.negSucc n).x
state_after: case negSucc
d : ℤ
a : Solution₁ d
hax : 0 < a.x
n : ℕ
⊢ 0 < (a ^ (n + 1))⁻¹.x

tactic: exact x_pow_pos hax (n + 1)
state_before: case negSucc
d : ℤ
a : Solution₁ d
hax : 0 < a.x
n : ℕ
⊢ 0 < (a ^ (n + 1))⁻¹.x
state_after: no goals
Theorem: Polynomial.trinomial_middle_coeff
File: Mathlib/Algebra/Polynomial/UnitTrinomial.lean

tactic: rw [trinomial_def, coeff_add, coeff_add, coeff_C_mul_X_pow, coeff_C_mul_X_pow, coeff_C_mul_X_pow,
  if_neg hkm.ne', if_pos rfl, if_neg hmn.ne, zero_add, add_zero]
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
⊢ (trinomial k m n u v w).coeff m = v
state_after: no goals
Theorem: CategoryTheory.tensor_sum
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

tactic: simp only [tensorHom_def, whiskerLeft_sum, Preadditive.comp_sum]
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : Preadditive C
inst✝¹ : MonoidalCategory C
inst✝ : MonoidalPreadditive C
P Q R S : C
J : Type u_2
s : Finset J
f : P ⟶ Q
g : J → (R ⟶ S)
⊢ f ⊗ ∑ j ∈ s, g j = ∑ j ∈ s, f ⊗ g j
state_after: no goals
Theorem: Multiset.disjoint_sum_right
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: simpa only [@disjoint_comm _ a] using disjoint_sum_left
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
a : Multiset α
i : Multiset (Multiset α)
⊢ a.Disjoint i.sum ↔ ∀ b ∈ i, a.Disjoint b
state_after: no goals
Theorem: MeasureTheory.StronglyMeasurable.prod_mk
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: refine ⟨fun n => SimpleFunc.pair (hf.approx n) (hg.approx n), fun x => ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
g : α → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
⊢ StronglyMeasurable fun x => (f x, g x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
g : α → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
x : α
⊢ Tendsto (fun n => ↑((fun n => (hf.approx n).pair (hg.approx n)) n) x) atTop (𝓝 ((fun x => (f x, g x)) x))

tactic: rw [nhds_prod_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
g : α → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
x : α
⊢ Tendsto (fun n => ↑((fun n => (hf.approx n).pair (hg.approx n)) n) x) atTop (𝓝 ((fun x => (f x, g x)) x))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
g : α → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
x : α
⊢ Tendsto (fun n => ↑((fun n => (hf.approx n).pair (hg.approx n)) n) x) atTop (𝓝 (f x) ×ˢ 𝓝 (g x))

tactic: exact Tendsto.prod_mk (hf.tendsto_approx x) (hg.tendsto_approx x)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
f✝ g✝ : α → β
m : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
g : α → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
x : α
⊢ Tendsto (fun n => ↑((fun n => (hf.approx n).pair (hg.approx n)) n) x) atTop (𝓝 (f x) ×ˢ 𝓝 (g x))
state_after: no goals
Theorem: antilipschitzWith_iff_le_mul_dist
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: simp only [antilipschitzWith_iff_le_mul_nndist, dist_nndist]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
⊢ AntilipschitzWith K f ↔ ∀ (x y : α), dist x y ≤ ↑K * dist (f x) (f y)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
⊢ (∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)) ↔ ∀ (x y : α), ↑(nndist x y) ≤ ↑K * ↑(nndist (f x) (f y))

tactic: norm_cast
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
⊢ (∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y)) ↔ ∀ (x y : α), ↑(nndist x y) ≤ ↑K * ↑(nndist (f x) (f y))
state_after: no goals
Theorem: Matrix.fromRows_neg
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

tactic: ext (i | i) j <;> simp
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹² : Fintype m
inst✝¹¹ : Fintype m₁
inst✝¹⁰ : Fintype m₂
inst✝⁹ : Fintype n
inst✝⁸ : Fintype n₁
inst✝⁷ : Fintype n₂
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq m₁
inst✝⁴ : DecidableEq m₂
inst✝³ : DecidableEq n
inst✝² : DecidableEq n₁
inst✝¹ : DecidableEq n₂
inst✝ : Neg R
A₁ : Matrix m₁ n R
A₂ : Matrix m₂ n R
⊢ -A₁.fromRows A₂ = (-A₁).fromRows (-A₂)
state_after: no goals
Theorem: Nat.coprime_add_self_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [Coprime, Coprime, gcd_add_self_left]
state_before: m n : ℕ
⊢ (m + n).Coprime n ↔ m.Coprime n
state_after: no goals
Theorem: ZFSet.toSet_insert
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext
state_before: x y : ZFSet
⊢ (insert x y).toSet = insert x y.toSet
state_after: case h
x y x✝ : ZFSet
⊢ x✝ ∈ (insert x y).toSet ↔ x✝ ∈ insert x y.toSet

tactic: simp
state_before: case h
x y x✝ : ZFSet
⊢ x✝ ∈ (insert x y).toSet ↔ x✝ ∈ insert x y.toSet
state_after: no goals