tasksource/leandojo huggingface dataset:
Theorem: Real.hasStrictFDerivAt_rpow_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: have : (fun x : ℝ × ℝ => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => exp (log x.1 * x.2) :=
  (continuousAt_fst.eventually (lt_mem_nhds hp)).mono fun p hp => rpow_def_of_pos hp _
state_before: x y z : ℝ
p : ℝ × ℝ
hp : 0 < p.fst
⊢ HasStrictFDerivAt (fun x => x.fst ^ x.snd)
    ((p.snd * p.fst ^ (p.snd - 1)) • ContinuousLinearMap.fst ℝ ℝ ℝ +
      (p.fst ^ p.snd * log p.fst) • ContinuousLinearMap.snd ℝ ℝ ℝ)
    p

tactic: refine' HasStrictFDerivAt.congr_of_eventuallyEq _ this.symm
state_before: x y z : ℝ
p : ℝ × ℝ
hp : 0 < p.fst
this : (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd)
⊢ HasStrictFDerivAt (fun x => x.fst ^ x.snd)
    ((p.snd * p.fst ^ (p.snd - 1)) • ContinuousLinearMap.fst ℝ ℝ ℝ +
      (p.fst ^ p.snd * log p.fst) • ContinuousLinearMap.snd ℝ ℝ ℝ)
    p

tactic: convert ((hasStrictFDerivAt_fst.log hp.ne').mul hasStrictFDerivAt_snd).exp using 1
state_before: x y z : ℝ
p : ℝ × ℝ
hp : 0 < p.fst
this : (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd)
⊢ HasStrictFDerivAt (fun x => exp (log x.fst * x.snd))
    ((p.snd * p.fst ^ (p.snd - 1)) • ContinuousLinearMap.fst ℝ ℝ ℝ +
      (p.fst ^ p.snd * log p.fst) • ContinuousLinearMap.snd ℝ ℝ ℝ)
    p

tactic: rw [rpow_sub_one hp.ne', ← rpow_def_of_pos hp, smul_add, smul_smul, mul_div_left_comm,
  div_eq_mul_inv, smul_smul, smul_smul, mul_assoc, add_comm]
state_before: case h.e'_10
x y z : ℝ
p : ℝ × ℝ
hp : 0 < p.fst
this : (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd)
⊢ (p.snd * p.fst ^ (p.snd - 1)) • ContinuousLinearMap.fst ℝ ℝ ℝ +
      (p.fst ^ p.snd * log p.fst) • ContinuousLinearMap.snd ℝ ℝ ℝ =
    exp (log p.fst * p.snd) •
      (log p.fst • ContinuousLinearMap.snd ℝ ℝ ℝ + p.snd • p.fst⁻¹ • ContinuousLinearMap.fst ℝ ℝ ℝ)
Theorem: AffineSubspace.WSameSide.map
File: Mathlib/Analysis/Convex/Side.lean

tactic: rcases h with ⟨p₁, hp₁, p₂, hp₂, h⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
h : WSameSide s x y
f : P →ᵃ[R] P'
⊢ WSameSide (AffineSubspace.map f s) (↑f x) (↑f y)

tactic: refine' ⟨f p₁, mem_map_of_mem f hp₁, f p₂, mem_map_of_mem f hp₂, _⟩
state_before: case intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
⊢ WSameSide (AffineSubspace.map f s) (↑f x) (↑f y)

tactic: simp_rw [← linearMap_vsub]
state_before: case intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
⊢ SameRay R (↑f x -ᵥ ↑f p₁) (↑f y -ᵥ ↑f p₂)

tactic: exact h.map f.linear
state_before: case intro.intro.intro.intro
R : Type u_1
V : Type u_2
V' : Type u_4
P : Type u_3
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
p₁ : P
hp₁ : p₁ ∈ s
p₂ : P
hp₂ : p₂ ∈ s
h : SameRay R (x -ᵥ p₁) (y -ᵥ p₂)
⊢ SameRay R (↑f.linear (x -ᵥ p₁)) (↑f.linear (y -ᵥ p₂))
Theorem: neg_lt_self_iff
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simp [neg_lt_iff_pos_add, ← two_mul, mul_pos_iff, zero_lt_one, (zero_lt_two' α).not_lt]
state_before: α : Type u
β : Type ?u.185898
inst✝ : LinearOrderedRing α
a b c : α
⊢ -a < a ↔ 0 < a
Theorem: Function.Antiperiodic.sub_const
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [sub_eq_add_neg] using h.add_const (-a)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.172212
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddCommGroup α
inst✝ : Neg β
h : Antiperiodic f c
a : α
⊢ Antiperiodic (fun x => f (x - a)) c
Theorem: Bool.or_eq_true
File: src/lean/Init/SimpLemmas.lean

tactic: cases a <;> cases b <;> decide
state_before: a b : Bool
⊢ ((a || b) = true) = (a = true ∨ b = true)
Theorem: MeasureTheory.inter_ae_eq_empty_of_ae_eq_empty_right
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: convert ae_eq_set_inter (ae_eq_refl s) h
state_before: α : Type u_1
β : Type ?u.130171
γ : Type ?u.130174
δ : Type ?u.130177
ι : Type ?u.130180
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : t =ᵐ[μ] ∅
⊢ s ∩ t =ᵐ[μ] ∅

tactic: rw [inter_empty]
state_before: case h.e'_5
α : Type u_1
β : Type ?u.130171
γ : Type ?u.130174
δ : Type ?u.130177
ι : Type ?u.130180
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : t =ᵐ[μ] ∅
⊢ ∅ = s ∩ ∅
Theorem: Ideal.comap_eq_of_scalar_tower_quotient
File: Mathlib/RingTheory/Ideal/Over.lean

tactic: ext x
state_before: R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I J : Ideal S
p : Ideal R
P : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra (R ⧸ p) (S ⧸ P)
inst✝ : IsScalarTower R (R ⧸ p) (S ⧸ P)
h : Function.Injective ↑(algebraMap (R ⧸ p) (S ⧸ P))
⊢ comap (algebraMap R S) P = p

tactic: constructor <;>
  rw [mem_comap, ← Quotient.eq_zero_iff_mem, ← Quotient.eq_zero_iff_mem, Quotient.mk_algebraMap,
    IsScalarTower.algebraMap_apply R (R ⧸ p) (S ⧸ P), Quotient.algebraMap_eq]
state_before: case h
R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I J : Ideal S
p : Ideal R
P : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra (R ⧸ p) (S ⧸ P)
inst✝ : IsScalarTower R (R ⧸ p) (S ⧸ P)
h : Function.Injective ↑(algebraMap (R ⧸ p) (S ⧸ P))
x : R
⊢ x ∈ comap (algebraMap R S) P ↔ x ∈ p

tactic: intro hx
state_before: case h.mp
R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I J : Ideal S
p : Ideal R
P : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra (R ⧸ p) (S ⧸ P)
inst✝ : IsScalarTower R (R ⧸ p) (S ⧸ P)
h : Function.Injective ↑(algebraMap (R ⧸ p) (S ⧸ P))
x : R
⊢ ↑(algebraMap (R ⧸ p) (S ⧸ P)) (↑(Quotient.mk p) x) = 0 → ↑(Quotient.mk p) x = 0

tactic: exact (injective_iff_map_eq_zero (algebraMap (R ⧸ p) (S ⧸ P))).mp h _ hx
state_before: case h.mp
R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I J : Ideal S
p : Ideal R
P : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra (R ⧸ p) (S ⧸ P)
inst✝ : IsScalarTower R (R ⧸ p) (S ⧸ P)
h : Function.Injective ↑(algebraMap (R ⧸ p) (S ⧸ P))
x : R
hx : ↑(algebraMap (R ⧸ p) (S ⧸ P)) (↑(Quotient.mk p) x) = 0
⊢ ↑(Quotient.mk p) x = 0

tactic: intro hx
state_before: case h.mpr
R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I J : Ideal S
p : Ideal R
P : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra (R ⧸ p) (S ⧸ P)
inst✝ : IsScalarTower R (R ⧸ p) (S ⧸ P)
h : Function.Injective ↑(algebraMap (R ⧸ p) (S ⧸ P))
x : R
⊢ ↑(Quotient.mk p) x = 0 → ↑(algebraMap (R ⧸ p) (S ⧸ P)) (↑(Quotient.mk p) x) = 0

tactic: rw [hx, RingHom.map_zero]
state_before: case h.mpr
R : Type u_1
inst✝⁴ : CommRing R
S : Type u_2
inst✝³ : CommRing S
f : R →+* S
I J : Ideal S
p : Ideal R
P : Ideal S
inst✝² : Algebra R S
inst✝¹ : Algebra (R ⧸ p) (S ⧸ P)
inst✝ : IsScalarTower R (R ⧸ p) (S ⧸ P)
h : Function.Injective ↑(algebraMap (R ⧸ p) (S ⧸ P))
x : R
hx : ↑(Quotient.mk p) x = 0
⊢ ↑(algebraMap (R ⧸ p) (S ⧸ P)) (↑(Quotient.mk p) x) = 0
Theorem: Primrec.list_range
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type ?u.312965
β : Type ?u.312968
γ : Type ?u.312971
σ : Type ?u.312974
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Nat.rec [] (fun n_1 IH => (n, n_1, IH).snd.snd ++ [(n, n_1, IH).snd.fst]) (id n) = List.range n

tactic: induction n <;> simp [*, List.range_succ]
state_before: α : Type ?u.312965
β : Type ?u.312968
γ : Type ?u.312971
σ : Type ?u.312974
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
⊢ Nat.rec [] (fun n IH => IH ++ [n]) n = List.range n
Theorem: NormedAddGroupHom.Equalizer.map_comp_map
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: ext
state_before: V : Type ?u.514605
W : Type ?u.514608
V₁ : Type u_1
V₂ : Type u_4
V₃ : Type u_6
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_3
W₂ : Type u_2
W₃ : Type u_5
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : NormedAddGroupHom.comp ψ f₁ = NormedAddGroupHom.comp f₂ φ
hg : NormedAddGroupHom.comp ψ g₁ = NormedAddGroupHom.comp g₂ φ
hf' : NormedAddGroupHom.comp ψ' f₂ = NormedAddGroupHom.comp f₃ φ'
hg' : NormedAddGroupHom.comp ψ' g₂ = NormedAddGroupHom.comp g₃ φ'
⊢ NormedAddGroupHom.comp (map φ' ψ' hf' hg') (map φ ψ hf hg) =
    map (NormedAddGroupHom.comp φ' φ) (NormedAddGroupHom.comp ψ' ψ)
      (_ :
        NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) f₁ =
          NormedAddGroupHom.comp f₃ (NormedAddGroupHom.comp φ' φ))
      (_ :
        NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) g₁ =
          NormedAddGroupHom.comp g₃ (NormedAddGroupHom.comp φ' φ))

tactic: rfl
state_before: case H.a
V : Type ?u.514605
W : Type ?u.514608
V₁ : Type u_1
V₂ : Type u_4
V₃ : Type u_6
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_3
W₂ : Type u_2
W₃ : Type u_5
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : NormedAddGroupHom.comp ψ f₁ = NormedAddGroupHom.comp f₂ φ
hg : NormedAddGroupHom.comp ψ g₁ = NormedAddGroupHom.comp g₂ φ
hf' : NormedAddGroupHom.comp ψ' f₂ = NormedAddGroupHom.comp f₃ φ'
hg' : NormedAddGroupHom.comp ψ' g₂ = NormedAddGroupHom.comp g₃ φ'
x✝ : { x // x ∈ equalizer f₁ g₁ }
⊢ ↑(↑(NormedAddGroupHom.comp (map φ' ψ' hf' hg') (map φ ψ hf hg)) x✝) =
    ↑(↑(map (NormedAddGroupHom.comp φ' φ) (NormedAddGroupHom.comp ψ' ψ)
            (_ :
              NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) f₁ =
                NormedAddGroupHom.comp f₃ (NormedAddGroupHom.comp φ' φ))
            (_ :
              NormedAddGroupHom.comp (NormedAddGroupHom.comp ψ' ψ) g₁ =
                NormedAddGroupHom.comp g₃ (NormedAddGroupHom.comp φ' φ)))
        x✝)
Theorem: StrictConvexOn.secant_strict_mono
File: Mathlib/Analysis/Convex/Slope.lean

tactic: cases' lt_or_gt_of_ne hxa with hxa hxa
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa : x ≠ a
hya : y ≠ a
hxy : x < y
⊢ (f x - f a) / (x - a) < (f y - f a) / (y - a)

tactic: cases' lt_or_gt_of_ne hya with hya hya
state_before: case inl
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa✝ : x ≠ a
hya : y ≠ a
hxy : x < y
hxa : x < a
⊢ (f x - f a) / (x - a) < (f y - f a) / (y - a)

tactic: convert hf.secant_strict_mono_aux3 hx ha hxy hya using 1 <;> rw [← neg_div_neg_eq] <;>
  field_simp
state_before: case inl.inl
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa✝ : x ≠ a
hya✝ : y ≠ a
hxy : x < y
hxa : x < a
hya : y < a
⊢ (f x - f a) / (x - a) < (f y - f a) / (y - a)

tactic: convert hf.slope_strict_mono_adjacent hx hy hxa hya using 1
state_before: case inl.inr
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa✝ : x ≠ a
hya✝ : y ≠ a
hxy : x < y
hxa : x < a
hya : y > a
⊢ (f x - f a) / (x - a) < (f y - f a) / (y - a)

tactic: rw [← neg_div_neg_eq]
state_before: case h.e'_3
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa✝ : x ≠ a
hya✝ : y ≠ a
hxy : x < y
hxa : x < a
hya : y > a
⊢ (f x - f a) / (x - a) = (f a - f x) / (a - x)

tactic: field_simp
state_before: case h.e'_3
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa✝ : x ≠ a
hya✝ : y ≠ a
hxy : x < y
hxa : x < a
hya : y > a
⊢ -(f x - f a) / -(x - a) = (f a - f x) / (a - x)

tactic: exact hf.secant_strict_mono_aux2 ha hy hxa hxy
state_before: case inr
𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConvexOn 𝕜 s f
a x y : 𝕜
ha : a ∈ s
hx : x ∈ s
hy : y ∈ s
hxa✝ : x ≠ a
hya : y ≠ a
hxy : x < y
hxa : x > a
⊢ (f x - f a) / (x - a) < (f y - f a) / (y - a)
Theorem: CstarRing.mul_star_self_ne_zero_iff
File: Mathlib/Analysis/NormedSpace/Star/Basic.lean

tactic: simp only [Ne.def, mul_star_self_eq_zero_iff]
state_before: 𝕜 : Type ?u.47608
E : Type u_1
α : Type ?u.47614
inst✝² : NonUnitalNormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
x : E
⊢ x * x⋆ ≠ 0 ↔ x ≠ 0
Theorem: constantCoeff_wittStructureInt
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

tactic: have inj : Function.Injective (Int.castRingHom ℚ) := by intro m n; exact Int.cast_inj.mp
state_before: p : ℕ
R : Type ?u.2047179
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
h : ↑constantCoeff Φ = 0
n : ℕ
⊢ ↑constantCoeff (wittStructureInt p Φ n) = 0

tactic: apply inj
state_before: p : ℕ
R : Type ?u.2047179
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
h : ↑constantCoeff Φ = 0
n : ℕ
inj : Function.Injective ↑(Int.castRingHom ℚ)
⊢ ↑constantCoeff (wittStructureInt p Φ n) = 0

tactic: rw [← constantCoeff_map, map_wittStructureInt, constantCoeff_wittStructureRat, RingHom.map_zero]
state_before: case a
p : ℕ
R : Type ?u.2047179
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
h : ↑constantCoeff Φ = 0
n : ℕ
inj : Function.Injective ↑(Int.castRingHom ℚ)
⊢ ↑(Int.castRingHom ℚ) (↑constantCoeff (wittStructureInt p Φ n)) = ↑(Int.castRingHom ℚ) 0

tactic: rw [constantCoeff_map, h, RingHom.map_zero]
state_before: case a.h
p : ℕ
R : Type ?u.2047179
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
h : ↑constantCoeff Φ = 0
n : ℕ
inj : Function.Injective ↑(Int.castRingHom ℚ)
⊢ ↑constantCoeff (↑(map (Int.castRingHom ℚ)) Φ) = 0

tactic: intro m n
state_before: p : ℕ
R : Type ?u.2047179
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
h : ↑constantCoeff Φ = 0
n : ℕ
⊢ Function.Injective ↑(Int.castRingHom ℚ)

tactic: exact Int.cast_inj.mp
state_before: p : ℕ
R : Type ?u.2047179
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
h : ↑constantCoeff Φ = 0
n✝ : ℕ
m n : ℤ
⊢ ↑(Int.castRingHom ℚ) m = ↑(Int.castRingHom ℚ) n → m = n
Theorem: Ordering.compares_swap
File: Mathlib/Order/Compare.lean

tactic: cases o
state_before: α : Type u_1
β : Type ?u.6152
inst✝ : LT α
a b : α
o : Ordering
⊢ Compares (swap o) a b ↔ Compares o b a

tactic: exact Iff.rfl
state_before: case lt
α : Type u_1
β : Type ?u.6152
inst✝ : LT α
a b : α
⊢ Compares (swap lt) a b ↔ Compares lt b a

tactic: exact eq_comm
state_before: case eq
α : Type u_1
β : Type ?u.6152
inst✝ : LT α
a b : α
⊢ Compares (swap eq) a b ↔ Compares eq b a

tactic: exact Iff.rfl
state_before: case gt
α : Type u_1
β : Type ?u.6152
inst✝ : LT α
a b : α
⊢ Compares (swap gt) a b ↔ Compares gt b a
Theorem: FractionalIdeal.map_one_div
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rw [map_div, map_one]
state_before: R : Type ?u.1246489
inst✝⁹ : CommRing R
S : Submonoid R
P : Type ?u.1246696
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝⁶ : CommRing R₁
K : Type u_2
inst✝⁵ : Field K
inst✝⁴ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝³ : IsDomain R₁
I✝ J : FractionalIdeal R₁⁰ K
K' : Type u_3
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
⊢ map (↑h) (1 / I) = 1 / map (↑h) I
Theorem: Int.gcd_eq_one_iff_coprime
File: Mathlib/RingTheory/Int/Basic.lean

tactic: constructor
state_before: a b : ℤ
⊢ gcd a b = 1 ↔ IsCoprime a b

tactic: intro hg
state_before: case mp
a b : ℤ
⊢ gcd a b = 1 → IsCoprime a b

tactic: obtain ⟨ua, -, ha⟩ := exists_unit_of_abs a
state_before: case mp
a b : ℤ
hg : gcd a b = 1
⊢ IsCoprime a b

tactic: obtain ⟨ub, -, hb⟩ := exists_unit_of_abs b
state_before: case mp.intro.intro
a b : ℤ
hg : gcd a b = 1
ua : ℤ
ha : ↑(natAbs a) = ua * a
⊢ IsCoprime a b

tactic: use Nat.gcdA (Int.natAbs a) (Int.natAbs b) * ua, Nat.gcdB (Int.natAbs a) (Int.natAbs b) * ub
state_before: case mp.intro.intro.intro.intro
a b : ℤ
hg : gcd a b = 1
ua : ℤ
ha : ↑(natAbs a) = ua * a
ub : ℤ
hb : ↑(natAbs b) = ub * b
⊢ IsCoprime a b

tactic: rw [mul_assoc, ← ha, mul_assoc, ← hb, mul_comm, mul_comm _ (Int.natAbs b : ℤ), ←
  Nat.gcd_eq_gcd_ab, ← gcd_eq_natAbs, hg, Int.ofNat_one]
state_before: case mp.intro.intro.intro.intro
a b : ℤ
hg : gcd a b = 1
ua : ℤ
ha : ↑(natAbs a) = ua * a
ub : ℤ
hb : ↑(natAbs b) = ub * b
⊢ Nat.gcdA (natAbs a) (natAbs b) * ua * a + Nat.gcdB (natAbs a) (natAbs b) * ub * b = 1

tactic: rintro ⟨r, s, h⟩
state_before: case mpr
a b : ℤ
⊢ IsCoprime a b → gcd a b = 1

tactic: by_contra hg
state_before: case mpr.intro.intro
a b r s : ℤ
h : r * a + s * b = 1
⊢ gcd a b = 1

tactic: obtain ⟨p, ⟨hp, ha, hb⟩⟩ := Nat.Prime.not_coprime_iff_dvd.mp hg
state_before: case mpr.intro.intro
a b r s : ℤ
h : r * a + s * b = 1
hg : ¬gcd a b = 1
⊢ False

tactic: apply Nat.Prime.not_dvd_one hp
state_before: case mpr.intro.intro.intro.intro.intro
a b r s : ℤ
h : r * a + s * b = 1
hg : ¬gcd a b = 1
p : ℕ
hp : Nat.Prime p
ha : p ∣ natAbs a
hb : p ∣ natAbs b
⊢ False

tactic: rw [← coe_nat_dvd, Int.ofNat_one, ← h]
state_before: case mpr.intro.intro.intro.intro.intro
a b r s : ℤ
h : r * a + s * b = 1
hg : ¬gcd a b = 1
p : ℕ
hp : Nat.Prime p
ha : p ∣ natAbs a
hb : p ∣ natAbs b
⊢ p ∣ 1

tactic: exact dvd_add ((coe_nat_dvd_left.mpr ha).mul_left _) ((coe_nat_dvd_left.mpr hb).mul_left _)
state_before: case mpr.intro.intro.intro.intro.intro
a b r s : ℤ
h : r * a + s * b = 1
hg : ¬gcd a b = 1
p : ℕ
hp : Nat.Prime p
ha : p ∣ natAbs a
hb : p ∣ natAbs b
⊢ ↑p ∣ r * a + s * b
Theorem: ContinuousLinearMap.adjoint_id
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: refine' Eq.symm _
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.826219
G : Type ?u.826222
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
⊢ ↑adjoint (id 𝕜 E) = id 𝕜 E

tactic: rw [eq_adjoint_iff]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.826219
G : Type ?u.826222
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
⊢ id 𝕜 E = ↑adjoint (id 𝕜 E)

tactic: simp
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.826219
G : Type ?u.826222
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : CompleteSpace E
inst✝¹ : CompleteSpace G
inst✝ : CompleteSpace F
⊢ ∀ (x : E) (y : (fun x => E) x), inner (↑(id 𝕜 E) x) y = inner x (↑(id 𝕜 E) y)
Theorem: tsub_le_tsub_iff_right
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [tsub_le_iff_right, tsub_add_cancel_of_le h]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : c ≤ b
⊢ a - c ≤ b - c ↔ a ≤ b
Theorem: CategoryTheory.Limits.image.factorThruImage_preComp
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp [image.preComp]
state_before: C : Type u
inst✝² : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
inst✝¹ : HasImage g
inst✝ : HasImage (f ≫ g)
⊢ factorThruImage (f ≫ g) ≫ preComp f g = f ≫ factorThruImage g
Theorem: List.traverse_append
File: Mathlib/Control/Traversable/Instances.lean

tactic: simp [functor_norm]
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f : α' → F β'
inst✝ : LawfulApplicative F
bs : List α'
⊢ traverse f ([] ++ bs) = Seq.seq ((fun x x_1 => x ++ x_1) <$> traverse f []) fun x => traverse f bs

tactic: simp [traverse_append as bs, functor_norm]
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f : α' → F β'
inst✝ : LawfulApplicative F
a : α'
as bs : List α'
⊢ traverse f (a :: as ++ bs) = Seq.seq ((fun x x_1 => x ++ x_1) <$> traverse f (a :: as)) fun x => traverse f bs

tactic: congr
state_before: F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f : α' → F β'
inst✝ : LawfulApplicative F
a : α'
as bs : List α'
⊢ (Seq.seq
      (Seq.seq (((fun x => x ∘ fun x x_1 => x ++ x_1) ∘ Function.comp ∘ fun x x_1 => x :: x_1) <$> f a) fun x =>
        traverse f as)
      fun x => traverse f bs) =
    Seq.seq (Seq.seq (((fun x => (fun x x_1 => x ++ x_1) ∘ x) ∘ fun x x_1 => x :: x_1) <$> f a) fun x => traverse f as)
      fun x => traverse f bs