1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Complex.eq_coe_norm_of_nonneg
File: Mathlib/Analysis/Complex/Basic.lean

tactic: lift z to ℝ using hz.2.symm
state_before: z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z : ℂ
hz : 0 ≤ z
⊢ z = ↑‖z‖
state_after: case intro
z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z : ℝ
hz : 0 ≤ ↑z
⊢ ↑z = ↑‖↑z‖

tactic: rw [norm_eq_abs, abs_ofReal, _root_.abs_of_nonneg (id hz.1 : 0 ≤ z)]
state_before: case intro
z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z : ℝ
hz : 0 ≤ ↑z
⊢ ↑z = ↑‖↑z‖
state_after: no goals
Theorem: LeftOrdContinuous.id
File: Mathlib/Order/OrdContinuous.lean

tactic: simpa only [image_id] using h
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f : α → β
s : Set α
x : α
h : IsLUB s x
⊢ IsLUB (id '' s) (id x)
state_after: no goals
Theorem: Relation.reflTransGen_eq_transGen
File: Mathlib/Logic/Relation.lean

tactic: rw [← transGen_reflGen, reflGen_eq_self hr]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hr : Reflexive r
⊢ ReflTransGen r = TransGen r
state_after: no goals
Theorem: Nat.factorization_choose_le_log
File: Mathlib/Data/Nat/Choose/Factorization.lean

tactic: by_cases h : (choose n k).factorization p = 0
state_before: p n k : ℕ
⊢ (n.choose k).factorization p ≤ log p n
state_after: case pos
p n k : ℕ
h : (n.choose k).factorization p = 0
⊢ (n.choose k).factorization p ≤ log p n

case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
⊢ (n.choose k).factorization p ≤ log p n

tactic: have hp : p.Prime := Not.imp_symm (choose n k).factorization_eq_zero_of_non_prime h
state_before: case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
⊢ (n.choose k).factorization p ≤ log p n
state_after: case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
⊢ (n.choose k).factorization p ≤ log p n

tactic: have hkn : k ≤ n := by
  refine le_of_not_lt fun hnk => h ?_
  simp [choose_eq_zero_of_lt hnk]
state_before: case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
⊢ (n.choose k).factorization p ≤ log p n
state_after: case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
hkn : k ≤ n
⊢ (n.choose k).factorization p ≤ log p n

tactic: rw [factorization_def _ hp, @padicValNat_def _ ⟨hp⟩ _ (choose_pos hkn)]
state_before: case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
hkn : k ≤ n
⊢ (n.choose k).factorization p ≤ log p n
state_after: case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
hkn : k ≤ n
⊢ (multiplicity p (n.choose k)).get ⋯ ≤ log p n

tactic: simp only [hp.multiplicity_choose hkn (lt_add_one _), PartENat.get_natCast]
state_before: case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
hkn : k ≤ n
⊢ (multiplicity p (n.choose k)).get ⋯ ≤ log p n
state_after: case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
hkn : k ≤ n
⊢ (Finset.filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Finset.Ico 1 (log p n + 1))).card ≤ log p n

tactic: exact (Finset.card_filter_le _ _).trans (le_of_eq (Nat.card_Ico _ _))
state_before: case neg
p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
hkn : k ≤ n
⊢ (Finset.filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Finset.Ico 1 (log p n + 1))).card ≤ log p n
state_after: no goals

tactic: simp [h]
state_before: case pos
p n k : ℕ
h : (n.choose k).factorization p = 0
⊢ (n.choose k).factorization p ≤ log p n
state_after: no goals

tactic: refine le_of_not_lt fun hnk => h ?_
state_before: p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
⊢ k ≤ n
state_after: p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
hnk : n < k
⊢ (n.choose k).factorization p = 0

tactic: simp [choose_eq_zero_of_lt hnk]
state_before: p n k : ℕ
h : ¬(n.choose k).factorization p = 0
hp : Prime p
hnk : n < k
⊢ (n.choose k).factorization p = 0
state_after: no goals
Theorem: AlgebraicClosure.toStepSucc.exists_root
File: Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean

tactic: obtain ⟨x, hx⟩ := @AdjoinMonic.exists_root _ (Step.field k n) _ hfm hfi
state_before: k : Type u
inst✝ : Field k
n : ℕ
f : (Step k n)[X]
hfm : f.Monic
hfi : Irreducible f
⊢ ∃ x, Polynomial.eval₂ (toStepSucc k n) x f = 0
state_after: case intro
k : Type u
inst✝ : Field k
n : ℕ
f : (Step k n)[X]
hfm : f.Monic
hfi : Irreducible f
x : AdjoinMonic (Step k n)
hx : Polynomial.eval₂ (toAdjoinMonic (Step k n)) x f = 0
⊢ ∃ x, Polynomial.eval₂ (toStepSucc k n) x f = 0

tactic: exact ⟨x, by apply hx⟩
state_before: case intro
k : Type u
inst✝ : Field k
n : ℕ
f : (Step k n)[X]
hfm : f.Monic
hfi : Irreducible f
x : AdjoinMonic (Step k n)
hx : Polynomial.eval₂ (toAdjoinMonic (Step k n)) x f = 0
⊢ ∃ x, Polynomial.eval₂ (toStepSucc k n) x f = 0
state_after: no goals

tactic: apply hx
state_before: k : Type u
inst✝ : Field k
n : ℕ
f : (Step k n)[X]
hfm : f.Monic
hfi : Irreducible f
x : AdjoinMonic (Step k n)
hx : Polynomial.eval₂ (toAdjoinMonic (Step k n)) x f = 0
⊢ Polynomial.eval₂ (toStepSucc k n) x f = 0
state_after: no goals
Theorem: Set.Ico_inter_Ici
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [← Ici_inter_Iio, ← Ici_inter_Iio, ← Ici_inter_Ici, inter_right_comm]
state_before: α : Type u_1
β : Type u_2
inst✝ : SemilatticeSup α
a b c : α
⊢ Ico a b ∩ Ici c = Ico (a ⊔ c) b
state_after: no goals
Theorem: multiplicity.pos_of_dvd
File: Mathlib/RingTheory/Multiplicity.lean

tactic: refine zero_lt_iff.2 fun h => ?_
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
hdiv : a ∣ b
⊢ 0 < (multiplicity a b).get hfin
state_after: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
hdiv : a ∣ b
h : (multiplicity a b).get hfin = 0
⊢ False

tactic: simpa [hdiv] using is_greatest' hfin (lt_one_iff.mpr h)
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
hfin : Finite a b
hdiv : a ∣ b
h : (multiplicity a b).get hfin = 0
⊢ False
state_after: no goals
Theorem: Set.not_injOn_infinite_finite_image
File: Mathlib/Data/Set/Finite.lean

tactic: have : Finite (f '' s) := finite_coe_iff.mpr h_fin
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
⊢ ¬InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this : Finite ↑(f '' s)
⊢ ¬InjOn f s

tactic: have : Infinite s := infinite_coe_iff.mpr h_inf
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this : Finite ↑(f '' s)
⊢ ¬InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
⊢ ¬InjOn f s

tactic: have h := not_injective_infinite_finite
          ((f '' s).codRestrict (s.restrict f) fun x => ⟨x, x.property, rfl⟩)
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
⊢ ¬InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
h : ¬Injective (codRestrict (s.restrict f) (f '' s) ⋯)
⊢ ¬InjOn f s

tactic: contrapose! h
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
h : ¬Injective (codRestrict (s.restrict f) (f '' s) ⋯)
⊢ ¬InjOn f s
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
h : InjOn f s
⊢ Injective (codRestrict (s.restrict f) (f '' s) ⋯)

tactic: rwa [injective_codRestrict, ← injOn_iff_injective]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
f : α → β
s : Set α
h_inf : s.Infinite
h_fin : (f '' s).Finite
this✝ : Finite ↑(f '' s)
this : Infinite ↑s
h : InjOn f s
⊢ Injective (codRestrict (s.restrict f) (f '' s) ⋯)
state_after: no goals
Theorem: Submonoid.fromLeftInv_eq_inv
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

tactic: rw [← mul_right_inj (x : M), mul_right_inv, mul_fromLeftInv]
state_before: M : Type u_1
inst✝ : Group M
S : Submonoid M
x : ↥S.leftInv
⊢ ↑(S.fromLeftInv x) = (↑x)⁻¹
state_after: no goals
Theorem: surjOn_Ioo_of_monotone_surjective
File: Mathlib/Order/Interval/Set/SurjOn.lean

tactic: intro p hp
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
⊢ SurjOn f (Ioo a b) (Ioo (f a) (f b))
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
p : β
hp : p ∈ Ioo (f a) (f b)
⊢ p ∈ f '' Ioo a b

tactic: rcases h_surj p with ⟨x, rfl⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b : α
p : β
hp : p ∈ Ioo (f a) (f b)
⊢ p ∈ f '' Ioo a b
state_after: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b x : α
hp : f x ∈ Ioo (f a) (f b)
⊢ f x ∈ f '' Ioo a b

tactic: refine ⟨x, mem_Ioo.2 ?_, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b x : α
hp : f x ∈ Ioo (f a) (f b)
⊢ f x ∈ f '' Ioo a b
state_after: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b x : α
hp : f x ∈ Ioo (f a) (f b)
⊢ a < x ∧ x < b

tactic: contrapose! hp
state_before: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b x : α
hp : f x ∈ Ioo (f a) (f b)
⊢ a < x ∧ x < b
state_after: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b x : α
hp : a < x → b ≤ x
⊢ f x ∉ Ioo (f a) (f b)

tactic: exact fun h => h.2.not_le (h_mono <| hp <| h_mono.reflect_lt h.1)
state_before: case intro
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : PartialOrder β
f : α → β
h_mono : Monotone f
h_surj : Surjective f
a b x : α
hp : a < x → b ≤ x
⊢ f x ∉ Ioo (f a) (f b)
state_after: no goals
Theorem: associative_of_commutative_of_le
File: Mathlib/Order/Basic.lean

tactic: rw [comm, comm b, comm _ c, comm a]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : PartialOrder α
f : α → α → α
comm : Commutative f
assoc : ∀ (a b c : α), f (f a b) c ≤ f a (f b c)
a b c : α
⊢ f a (f b c) ≤ f (f a b) c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : PartialOrder α
f : α → α → α
comm : Commutative f
assoc : ∀ (a b c : α), f (f a b) c ≤ f a (f b c)
a b c : α
⊢ f (f c b) a ≤ f c (f b a)

tactic: exact assoc _ _ _
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : PartialOrder α
f : α → α → α
comm : Commutative f
assoc : ∀ (a b c : α), f (f a b) c ≤ f a (f b c)
a b c : α
⊢ f (f c b) a ≤ f c (f b a)
state_after: no goals
Theorem: Set.Finite.finite_of_compl
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← finite_univ_iff, ← union_compl_self s]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : s.Finite
hsc : sᶜ.Finite
⊢ Finite α
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : s.Finite
hsc : sᶜ.Finite
⊢ (s ∪ sᶜ).Finite

tactic: exact hs.union hsc
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : s.Finite
hsc : sᶜ.Finite
⊢ (s ∪ sᶜ).Finite
state_after: no goals
Theorem: MeasureTheory.union_cylinder_same
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

tactic: classical rw [union_cylinder]; rfl
state_before: ι : Type u_1
α : ι → Type u_2
s : Finset ι
S₁ S₂ : Set ((i : { x // x ∈ s }) → α ↑i)
⊢ cylinder s S₁ ∪ cylinder s S₂ = cylinder s (S₁ ∪ S₂)
state_after: no goals

tactic: rw [union_cylinder]
state_before: ι : Type u_1
α : ι → Type u_2
s : Finset ι
S₁ S₂ : Set ((i : { x // x ∈ s }) → α ↑i)
⊢ cylinder s S₁ ∪ cylinder s S₂ = cylinder s (S₁ ∪ S₂)
state_after: ι : Type u_1
α : ι → Type u_2
s : Finset ι
S₁ S₂ : Set ((i : { x // x ∈ s }) → α ↑i)
⊢ cylinder (s ∪ s) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∪ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂) = cylinder s (S₁ ∪ S₂)

tactic: rfl
state_before: ι : Type u_1
α : ι → Type u_2
s : Finset ι
S₁ S₂ : Set ((i : { x // x ∈ s }) → α ↑i)
⊢ cylinder (s ∪ s) ((fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₁ ∪ (fun f j => f ⟨↑j, ⋯⟩) ⁻¹' S₂) = cylinder s (S₁ ∪ S₂)
state_after: no goals
Theorem: ENNReal.natCast_le_ofReal
File: Mathlib/Data/ENNReal/Real.lean

tactic: simp only [← not_lt, ofReal_lt_natCast hn]
state_before: a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
n : ℕ
p : ℝ
hn : n ≠ 0
⊢ ↑n ≤ ENNReal.ofReal p ↔ ↑n ≤ p
state_after: no goals
Theorem: PresheafOfModules.restrictionApp_comp
File: Mathlib/Algebra/Category/ModuleCat/Presheaf.lean

tactic: aesop
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
M : PresheafOfModules R
X Y Z : Cᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
⊢ restrictionApp (f ≫ g) M =
    restrictionApp f M ≫
      (ModuleCat.restrictScalars (R.map f)).map (restrictionApp g M) ≫
        (ModuleCat.restrictScalarsComp' (R.map f) (R.map g) (R.map (f ≫ g)) ⋯).inv.app (M.obj Z)
state_after: no goals
Theorem: MeasurableEmbedding.measurable_rangeSplitting
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

tactic: rwa [preimage_rangeSplitting hf.injective,
  ← (subtype_coe hf.measurableSet_range).measurableSet_image, ← image_comp,
  coe_comp_rangeFactorization, hf.measurableSet_image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → γ
hf : MeasurableEmbedding f
s : Set α
hs : MeasurableSet s
⊢ MeasurableSet (rangeSplitting f ⁻¹' s)
state_after: no goals
Theorem: CircleDeg1Lift.lt_translationNumber_of_forall_add_lt
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: obtain ⟨x, -, hx⟩ : ∃ x ∈ Icc (0 : ℝ) 1, ∀ y ∈ Icc (0 : ℝ) 1, f x - x ≤ f y - y :=
  isCompact_Icc.exists_isMinOn (nonempty_Icc.2 zero_le_one) (hf.sub continuous_id).continuousOn
state_before: f g : CircleDeg1Lift
hf : Continuous ⇑f
z : ℝ
hz : ∀ (x : ℝ), x + z < f x
⊢ z < τ f
state_after: case intro.intro
f g : CircleDeg1Lift
hf : Continuous ⇑f
z : ℝ
hz : ∀ (x : ℝ), x + z < f x
x : ℝ
hx : ∀ y ∈ Icc 0 1, f x - x ≤ f y - y
⊢ z < τ f

tactic: refine lt_of_lt_of_le (lt_sub_iff_add_lt'.2 <| hz x) ?_
state_before: case intro.intro
f g : CircleDeg1Lift
hf : Continuous ⇑f
z : ℝ
hz : ∀ (x : ℝ), x + z < f x
x : ℝ
hx : ∀ y ∈ Icc 0 1, f x - x ≤ f y - y
⊢ z < τ f
state_after: case intro.intro
f g : CircleDeg1Lift
hf : Continuous ⇑f
z : ℝ
hz : ∀ (x : ℝ), x + z < f x
x : ℝ
hx : ∀ y ∈ Icc 0 1, f x - x ≤ f y - y
⊢ f x - x ≤ τ f

tactic: apply le_translationNumber_of_add_le
state_before: case intro.intro
f g : CircleDeg1Lift
hf : Continuous ⇑f
z : ℝ
hz : ∀ (x : ℝ), x + z < f x
x : ℝ
hx : ∀ y ∈ Icc 0 1, f x - x ≤ f y - y
⊢ f x - x ≤ τ f
state_after: case intro.intro.hz
f g : CircleDeg1Lift
hf : Continuous ⇑f
z : ℝ
hz : ∀ (x : ℝ), x + z < f x
x : ℝ
hx : ∀ y ∈ Icc 0 1, f x - x ≤ f y - y
⊢ ∀ (x_1 : ℝ), x_1 + (f x - x) ≤ f x_1

tactic: simp only [← le_sub_iff_add_le']
state_before: case intro.intro.hz
f g : CircleDeg1Lift
hf : Continuous ⇑f
z : ℝ
hz : ∀ (x : ℝ), x + z < f x
x : ℝ
hx : ∀ y ∈ Icc 0 1, f x - x ≤ f y - y
⊢ ∀ (x_1 : ℝ), x_1 + (f x - x) ≤ f x_1
state_after: case intro.intro.hz
f g : CircleDeg1Lift
hf : Continuous ⇑f
z : ℝ
hz : ∀ (x : ℝ), x + z < f x
x : ℝ
hx : ∀ y ∈ Icc 0 1, f x - x ≤ f y - y
⊢ ∀ (x_1 : ℝ), f x - x ≤ f x_1 - x_1

tactic: exact f.forall_map_sub_of_Icc _ hx
state_before: case intro.intro.hz
f g : CircleDeg1Lift
hf : Continuous ⇑f
z : ℝ
hz : ∀ (x : ℝ), x + z < f x
x : ℝ
hx : ∀ y ∈ Icc 0 1, f x - x ≤ f y - y
⊢ ∀ (x_1 : ℝ), f x - x ≤ f x_1 - x_1
state_after: no goals
Theorem: Basis.orientation_comp_linearEquiv_eq_neg_iff_det_neg
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: rw [orientation_map, e.map_orientation_eq_det_inv_smul, units_inv_smul, units_smul_eq_neg_iff,
  LinearEquiv.coe_det]
state_before: R : Type u_1
inst✝⁴ : LinearOrderedCommRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_3
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
f : M ≃ₗ[R] M
⊢ (e.map f).orientation = -e.orientation ↔ LinearMap.det ↑f < 0
state_after: no goals
Theorem: Nat.Coprime.gcd_mul_left_cancel
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

tactic: rw [Coprime, Nat.gcd_assoc, H.symm.gcd_eq_one, gcd_one_right]
state_before: k n m : Nat
H : k.Coprime n
⊢ ((k * m).gcd n).Coprime k
state_after: no goals
Theorem: Nat.floor_div_eq_div
File: Mathlib/Algebra/Order/Floor.lean

tactic: convert floor_div_nat (m : α) n
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemifield α
inst✝ : FloorSemiring α
m n : ℕ
⊢ ⌊↑m / ↑n⌋₊ = m / n
state_after: case h.e'_3.h.e'_5
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemifield α
inst✝ : FloorSemiring α
m n : ℕ
⊢ m = ⌊↑m⌋₊

tactic: rw [m.floor_natCast]
state_before: case h.e'_3.h.e'_5
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemifield α
inst✝ : FloorSemiring α
m n : ℕ
⊢ m = ⌊↑m⌋₊
state_after: no goals
Theorem: ComplexShape.symm_symm
File: Mathlib/Algebra/Homology/ComplexShape.lean

tactic: ext
state_before: ι : Type u_1
c : ComplexShape ι
⊢ c.symm.symm = c
state_after: case Rel.h.h.a
ι : Type u_1
c : ComplexShape ι
x✝¹ x✝ : ι
⊢ c.symm.symm.Rel x✝¹ x✝ ↔ c.Rel x✝¹ x✝

tactic: simp
state_before: case Rel.h.h.a
ι : Type u_1
c : ComplexShape ι
x✝¹ x✝ : ι
⊢ c.symm.symm.Rel x✝¹ x✝ ↔ c.Rel x✝¹ x✝
state_after: no goals
Theorem: Compactum.join_distrib
File: Mathlib/Topology/Category/Compactum.lean

tactic: change ((β ).μ.app _ ≫ X.a) _ = _
state_before: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ X.str (X.join uux) = X.str (Ultrafilter.map X.str uux)
state_after: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.μ.app X.A ≫ X.a) uux = X.str (Ultrafilter.map X.str uux)

tactic: rw [Monad.Algebra.assoc]
state_before: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.μ.app X.A ≫ X.a) uux = X.str (Ultrafilter.map X.str uux)
state_after: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.map X.a ≫ X.a) uux = X.str (Ultrafilter.map X.str uux)

tactic: rfl
state_before: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.map X.a ≫ X.a) uux = X.str (Ultrafilter.map X.str uux)
state_after: no goals
Theorem: CochainComplex.shiftFunctorComm_hom_app_f
File: Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean

tactic: rw [add_assoc, add_comm b, add_assoc]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ p + b + a = p + a + b
state_after: no goals

tactic: rw [shiftFunctorComm_eq _ _ _ _ rfl]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ ((shiftFunctorComm (CochainComplex C ℤ) a b).hom.app K).f p = (XIsoOfEq K ⋯).hom
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ (((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b (a + b) ⋯).symm ≪≫
                CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) b a (a + b) ⋯).hom.app
          K).f
      p =
    (XIsoOfEq K ⋯).hom

tactic: dsimp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ (((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b (a + b) ⋯).symm ≪≫
                CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) b a (a + b) ⋯).hom.app
          K).f
      p =
    (XIsoOfEq K ⋯).hom
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b (a + b) ⋯).inv.app K).f p ≫
      ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) b a (a + b) ⋯).hom.app K).f p =
    (XIsoOfEq K ⋯).hom

tactic: rw [shiftFunctorAdd'_inv_app_f', shiftFunctorAdd'_hom_app_f']
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b (a + b) ⋯).inv.app K).f p ≫
      ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) b a (a + b) ⋯).hom.app K).f p =
    (XIsoOfEq K ⋯).hom
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ (XIsoOfEq K ⋯).hom ≫ (XIsoOfEq K ⋯).hom = (XIsoOfEq K ⋯).hom

tactic: simp only [XIsoOfEq, eqToIso.hom, eqToHom_trans]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ (XIsoOfEq K ⋯).hom ≫ (XIsoOfEq K ⋯).hom = (XIsoOfEq K ⋯).hom
state_after: no goals
Theorem: Polynomial.eq_of_monic_of_associated
File: Mathlib/Algebra/Polynomial/Monic.lean

tactic: obtain ⟨u, rfl⟩ := hpq
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
hq : q.Monic
hpq : Associated p q
⊢ p = q
state_after: case intro
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p r : R[X]
hp : p.Monic
u : R[X]ˣ
hq : (p * ↑u).Monic
⊢ p = p * ↑u

tactic: rw [(hp.of_mul_monic_left hq).eq_one_of_isUnit u.isUnit, mul_one]
state_before: case intro
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p r : R[X]
hp : p.Monic
u : R[X]ˣ
hq : (p * ↑u).Monic
⊢ p = p * ↑u
state_after: no goals