1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.naturality
File: Mathlib/Control/Traversable/Instances.lean

tactic: induction x <;> simp! [*, functor_norm, ApplicativeTransformation.preserves_map,
  ApplicativeTransformation.preserves_seq, ApplicativeTransformation.preserves_pure]
state_before: F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
x : List α
⊢ (fun {α} => η.app α) (List.traverse f x) = List.traverse ((fun {α} => η.app α) ∘ f) x
state_after: no goals
Theorem: Finsupp.toFreeAbelianGroup_toFinsupp
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: rw [← AddMonoidHom.comp_apply, Finsupp.toFreeAbelianGroup_comp_toFinsupp, AddMonoidHom.id_apply]
state_before: X✝ : Type u_1
X : Type u_2
x : FreeAbelianGroup X
⊢ toFreeAbelianGroup (toFinsupp x) = x
state_after: no goals
Theorem: Cardinal.mul_eq_right
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [mul_comm, mul_eq_left hb ha ha']
state_before: a b : Cardinal.{u_1}
hb : ℵ₀ ≤ b
ha : a ≤ b
ha' : a ≠ 0
⊢ a * b = b
state_after: no goals
Theorem: principal_exterior
File: Mathlib/Topology/AlexandrovDiscrete.lean

tactic: rw [← nhdsSet_exterior, isOpen_exterior.nhdsSet_eq]
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s✝ t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
s : Set α
⊢ 𝓟 (exterior s) = 𝓝ˢ s
state_after: no goals
Theorem: Polynomial.natDegree_linear
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [natDegree_add_C, natDegree_C_mul_X a ha]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
ha : a ≠ 0
⊢ (C a * X + C b).natDegree = 1
state_after: no goals
Theorem: ENNReal.tendsto_nhds_top_iff_nat
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simpa only [ENNReal.coe_natCast] using h n
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
m : α → ℝ≥0∞
f : Filter α
h : ∀ (x : ℝ≥0), ∀ᶠ (a : α) in f, ↑x < m a
n : ℕ
⊢ ∀ᶠ (a : α) in f, ↑n < m a
state_after: no goals

tactic: rwa [← ENNReal.coe_natCast, coe_lt_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
m : α → ℝ≥0∞
f : Filter α
h : ∀ (n : ℕ), ∀ᶠ (a : α) in f, ↑n < m a
x : ℝ≥0
n : ℕ
hn : x < ↑n
y : α
⊢ ↑x < ↑n
state_after: no goals
Theorem: Polynomial.mul_X_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: induction p using Polynomial.induction_on' with
| h_add p q hp hq =>
  simp only [hp, hq, add_mul, add_comp]
| h_monomial n b =>
  simp only [pow_succ, mul_assoc, monomial_mul_X, monomial_comp]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ (p * X).comp r = p.comp r * r
state_after: no goals

tactic: simp only [hp, hq, add_mul, add_comp]
state_before: case h_add
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
hp : (p * X).comp r = p.comp r * r
hq : (q * X).comp r = q.comp r * r
⊢ ((p + q) * X).comp r = (p + q).comp r * r
state_after: no goals

tactic: simp only [pow_succ, mul_assoc, monomial_mul_X, monomial_comp]
state_before: case h_monomial
R : Type u
S : Type v
T : Type w
ι : Type y
a b✝ : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
b : R
⊢ ((monomial n) b * X).comp r = ((monomial n) b).comp r * r
state_after: no goals
Theorem: AffineMap.lineMap_vsub_right
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: rw [← lineMap_apply_one_sub, lineMap_vsub_left]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type u_4
P2 : Type u_5
V3 : Type u_6
P3 : Type u_7
V4 : Type u_8
P4 : Type u_9
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
p₀ p₁ : P1
c : k
⊢ (lineMap p₀ p₁) c -ᵥ p₁ = (1 - c) • (p₀ -ᵥ p₁)
state_after: no goals
Theorem: EuclideanGeometry.angle_eq_pi_div_two_of_oangle_eq_neg_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

tactic: rw [angle, ← InnerProductGeometry.inner_eq_zero_iff_angle_eq_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(-π / 2)
⊢ ∠ p₁ p₂ p₃ = π / 2
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(-π / 2)
⊢ ⟪p₁ -ᵥ p₂, p₃ -ᵥ p₂⟫_ℝ = 0

tactic: exact o.inner_eq_zero_of_oangle_eq_neg_pi_div_two h
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(-π / 2)
⊢ ⟪p₁ -ᵥ p₂, p₃ -ᵥ p₂⟫_ℝ = 0
state_after: no goals
Theorem: PosNum.add_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [one_add b, succ_to_nat, add_comm, cast_one]
state_before: α : Type u_1
b : PosNum
⊢ ↑(1 + b) = ↑1 + ↑b
state_after: no goals

tactic: rw [add_one a, succ_to_nat, cast_one]
state_before: α : Type u_1
a : PosNum
⊢ ↑(a + 1) = ↑a + ↑1
state_after: no goals

tactic: simp [add_left_comm]
state_before: α : Type u_1
a b : PosNum
⊢ ↑a + ↑b + (↑a + ↑b) + 1 = ↑a + ↑a + (↑b + ↑b + 1)
state_after: no goals

tactic: simp [add_comm, add_left_comm]
state_before: α : Type u_1
a b : PosNum
⊢ ↑a + ↑b + (↑a + ↑b) + 1 = ↑a + ↑a + 1 + (↑b + ↑b)
state_after: no goals

tactic: rw [succ_to_nat, add_to_nat a b]
state_before: α : Type u_1
a b : PosNum
⊢ ↑(a + b).succ + ↑(a + b).succ = ↑a + ↑a + 1 + (↑b + ↑b + 1)
state_after: α : Type u_1
a b : PosNum
⊢ ↑a + ↑b + 1 + (↑a + ↑b + 1) = ↑a + ↑a + 1 + (↑b + ↑b + 1)

tactic: simp [add_left_comm]
state_before: α : Type u_1
a b : PosNum
⊢ ↑a + ↑b + 1 + (↑a + ↑b + 1) = ↑a + ↑a + 1 + (↑b + ↑b + 1)
state_after: no goals
Theorem: Nat.nth_apply_eq_orderIsoOfNat
File: Mathlib/Data/Nat/Nth.lean

tactic: rw [nth, dif_neg hf]
state_before: p : ℕ → Prop
hf : (setOf p).Infinite
n : ℕ
⊢ nth p n = ↑((Subtype.orderIsoOfNat (setOf p)) n)
state_after: no goals
Theorem: minpoly.ne_one
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: intro h
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
⊢ minpoly A x ≠ 1
state_after: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ False

tactic: refine (one_ne_zero : (1 : B) ≠ 0) ?_
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ False
state_after: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ 1 = 0

tactic: simpa using congr_arg (Polynomial.aeval x) h
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁵ : CommRing A
inst✝⁴ : Ring B
inst✝³ : Ring B'
inst✝² : Algebra A B
inst✝¹ : Algebra A B'
x : B
inst✝ : Nontrivial B
h : minpoly A x = 1
⊢ 1 = 0
state_after: no goals
Theorem: Polynomial.reverse_C_add
File: Mathlib/Algebra/Polynomial/Reverse.lean

tactic: rw [add_comm, reverse_add_C, add_comm]
state_before: R : Type u_1
inst✝ : Semiring R
f p : R[X]
t : R
⊢ (C t + p).reverse = C t * X ^ p.natDegree + p.reverse
state_after: no goals
Theorem: CategoryTheory.Limits.Types.isConnected_iff_colimit_constPUnitFunctor_iso_pUnit
File: Mathlib/CategoryTheory/Limits/IsConnected.lean

tactic: refine ⟨fun _ => ⟨colimitConstPUnitIsoPUnit.{w} C⟩, fun ⟨h⟩ => ?_⟩
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimit (constPUnitFunctor C)
⊢ IsConnected C ↔ Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{w + 1})
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimit (constPUnitFunctor C)
x✝ : Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{w + 1})
h : colimit (constPUnitFunctor C) ≅ PUnit.{w + 1}
⊢ IsConnected C

tactic: have : Nonempty C := nonempty_of_nonempty_colimit <| Nonempty.map h.inv inferInstance
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimit (constPUnitFunctor C)
x✝ : Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{w + 1})
h : colimit (constPUnitFunctor C) ≅ PUnit.{w + 1}
⊢ IsConnected C
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimit (constPUnitFunctor C)
x✝ : Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{w + 1})
h : colimit (constPUnitFunctor C) ≅ PUnit.{w + 1}
this : Nonempty C
⊢ IsConnected C

tactic: refine zigzag_isConnected <| fun c d => ?_
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimit (constPUnitFunctor C)
x✝ : Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{w + 1})
h : colimit (constPUnitFunctor C) ≅ PUnit.{w + 1}
this : Nonempty C
⊢ IsConnected C
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimit (constPUnitFunctor C)
x✝ : Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{w + 1})
h : colimit (constPUnitFunctor C) ≅ PUnit.{w + 1}
this : Nonempty C
c d : C
⊢ Zigzag c d

tactic: refine zigzag_of_eqvGen_quot_rel _ (constPUnitFunctor C) ⟨c, PUnit.unit⟩ ⟨d, PUnit.unit⟩ ?_
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimit (constPUnitFunctor C)
x✝ : Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{w + 1})
h : colimit (constPUnitFunctor C) ≅ PUnit.{w + 1}
this : Nonempty C
c d : C
⊢ Zigzag c d
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimit (constPUnitFunctor C)
x✝ : Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{w + 1})
h : colimit (constPUnitFunctor C) ≅ PUnit.{w + 1}
this : Nonempty C
c d : C
⊢ EqvGen (Quot.Rel (constPUnitFunctor C)) ⟨c, PUnit.unit⟩ ⟨d, PUnit.unit⟩

tactic: exact colimit_eq <| h.toEquiv.injective rfl
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimit (constPUnitFunctor C)
x✝ : Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{w + 1})
h : colimit (constPUnitFunctor C) ≅ PUnit.{w + 1}
this : Nonempty C
c d : C
⊢ EqvGen (Quot.Rel (constPUnitFunctor C)) ⟨c, PUnit.unit⟩ ⟨d, PUnit.unit⟩
state_after: no goals
Theorem: QPF.Fix.mk_dest
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: change (Fix.mk ∘ Fix.dest) x = id x
state_before: F : Type u → Type u
q : QPF F
x : Fix F
⊢ mk x.dest = x
state_after: F : Type u → Type u
q : QPF F
x : Fix F
⊢ (mk ∘ dest) x = id x

tactic: apply Fix.ind_rec (mk ∘ dest) id
state_before: F : Type u → Type u
q : QPF F
x : Fix F
⊢ (mk ∘ dest) x = id x
state_after: case h
F : Type u → Type u
q : QPF F
x : Fix F
⊢ ∀ (x : F (Fix F)), (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)

tactic: intro x
state_before: case h
F : Type u → Type u
q : QPF F
x : Fix F
⊢ ∀ (x : F (Fix F)), (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)
state_after: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)

tactic: rw [Function.comp_apply, id_eq, Fix.dest, Fix.rec_eq, id_map, comp_map]
state_before: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
⊢ (mk ∘ dest) <$> x = id <$> x → (mk ∘ dest) (mk x) = id (mk x)
state_after: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
⊢ mk <$> rec (Functor.map mk) <$> x = x → mk (mk <$> rec (Functor.map mk) <$> x) = mk x

tactic: intro h
state_before: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
⊢ mk <$> rec (Functor.map mk) <$> x = x → mk (mk <$> rec (Functor.map mk) <$> x) = mk x
state_after: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
h : mk <$> rec (Functor.map mk) <$> x = x
⊢ mk (mk <$> rec (Functor.map mk) <$> x) = mk x

tactic: rw [h]
state_before: case h
F : Type u → Type u
q : QPF F
x✝ : Fix F
x : F (Fix F)
h : mk <$> rec (Functor.map mk) <$> x = x
⊢ mk (mk <$> rec (Functor.map mk) <$> x) = mk x
state_after: no goals
Theorem: Real.rpow_inv_eq
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← rpow_left_inj _ hy hz, rpow_inv_rpow hx hz]
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : z ≠ 0
⊢ x ^ z⁻¹ = y ↔ x = y ^ z
state_after: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : z ≠ 0
⊢ 0 ≤ x ^ z⁻¹

tactic: positivity
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : z ≠ 0
⊢ 0 ≤ x ^ z⁻¹
state_after: no goals
Theorem: Matrix.det_eq_prod_roots_charpoly_of_splits
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Eigs.lean

tactic: rw [det_eq_sign_charpoly_coeff, ← charpoly_natDegree_eq_dim A,
  Polynomial.prod_roots_eq_coeff_zero_of_monic_of_split A.charpoly_monic hAps, ← mul_assoc,
  ← pow_two, pow_right_comm, neg_one_sq, one_pow, one_mul]
state_before: n : Type u_1
inst✝² : Fintype n
inst✝¹ : DecidableEq n
R : Type u_2
inst✝ : Field R
A : Matrix n n R
hAps : Splits (RingHom.id R) A.charpoly
⊢ A.det = A.charpoly.roots.prod
state_after: no goals
Theorem: ENNReal.rpow_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases' lt_or_le 0 p with hp_pos hp_nonpos
state_before: p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
⊢ 0 < x ^ p
state_after: case inl
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
hp_pos : 0 < p
⊢ 0 < x ^ p

case inr
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
hp_nonpos : p ≤ 0
⊢ 0 < x ^ p

tactic: exact rpow_pos_of_nonneg hx_pos (le_of_lt hp_pos)
state_before: case inl
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
hp_pos : 0 < p
⊢ 0 < x ^ p
state_after: no goals

tactic: rw [← neg_neg p, rpow_neg, ENNReal.inv_pos]
state_before: case inr
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
hp_nonpos : p ≤ 0
⊢ 0 < x ^ p
state_after: case inr
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
hp_nonpos : p ≤ 0
⊢ x ^ (-p) ≠ ⊤

tactic: exact rpow_ne_top_of_nonneg (Right.nonneg_neg_iff.mpr hp_nonpos) hx_ne_top
state_before: case inr
p : ℝ
x : ℝ≥0∞
hx_pos : 0 < x
hx_ne_top : x ≠ ⊤
hp_nonpos : p ≤ 0
⊢ x ^ (-p) ≠ ⊤
state_after: no goals
Theorem: CauSeq.pos_add_limZero
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: cases' h j ij with h₁ h₂
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g : CauSeq α abs
F : α
F0 : F > 0
hF : ∃ i, ∀ j ≥ i, F ≤ ↑f j
H : g.LimZero
i : ℕ
h : ∀ j ≥ i, F ≤ ↑f j ∧ |↑g j| < F / 2
j : ℕ
ij : j ≥ i
⊢ F / 2 ≤ ↑(f + g) j
state_after: case intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g : CauSeq α abs
F : α
F0 : F > 0
hF : ∃ i, ∀ j ≥ i, F ≤ ↑f j
H : g.LimZero
i : ℕ
h : ∀ j ≥ i, F ≤ ↑f j ∧ |↑g j| < F / 2
j : ℕ
ij : j ≥ i
h₁ : F ≤ ↑f j
h₂ : |↑g j| < F / 2
⊢ F / 2 ≤ ↑(f + g) j

tactic: have := add_le_add h₁ (le_of_lt (abs_lt.1 h₂).1)
state_before: case intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g : CauSeq α abs
F : α
F0 : F > 0
hF : ∃ i, ∀ j ≥ i, F ≤ ↑f j
H : g.LimZero
i : ℕ
h : ∀ j ≥ i, F ≤ ↑f j ∧ |↑g j| < F / 2
j : ℕ
ij : j ≥ i
h₁ : F ≤ ↑f j
h₂ : |↑g j| < F / 2
⊢ F / 2 ≤ ↑(f + g) j
state_after: case intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g : CauSeq α abs
F : α
F0 : F > 0
hF : ∃ i, ∀ j ≥ i, F ≤ ↑f j
H : g.LimZero
i : ℕ
h : ∀ j ≥ i, F ≤ ↑f j ∧ |↑g j| < F / 2
j : ℕ
ij : j ≥ i
h₁ : F ≤ ↑f j
h₂ : |↑g j| < F / 2
this : F + -(F / 2) ≤ ↑f j + ↑g j
⊢ F / 2 ≤ ↑(f + g) j

tactic: rwa [← sub_eq_add_neg, sub_self_div_two] at this
state_before: case intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g : CauSeq α abs
F : α
F0 : F > 0
hF : ∃ i, ∀ j ≥ i, F ≤ ↑f j
H : g.LimZero
i : ℕ
h : ∀ j ≥ i, F ≤ ↑f j ∧ |↑g j| < F / 2
j : ℕ
ij : j ≥ i
h₁ : F ≤ ↑f j
h₂ : |↑g j| < F / 2
this : F + -(F / 2) ≤ ↑f j + ↑g j
⊢ F / 2 ≤ ↑(f + g) j
state_after: no goals
Theorem: Real.log_nonneg_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← not_lt, log_neg_iff hx, not_lt]
state_before: x y : ℝ
hx : 0 < x
⊢ 0 ≤ log x ↔ 1 ≤ x
state_after: no goals
Theorem: Matrix.det_smul_inv_mulVec_eq_cramer
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [cramer_eq_adjugate_mulVec, A.nonsing_inv_apply h, ← smul_mulVec_assoc, smul_smul,
  h.mul_val_inv, one_smul]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
b : n → α
h : IsUnit A.det
⊢ A.det • A⁻¹ *ᵥ b = A.cramer b
state_after: no goals
Theorem: ContinuousLinearEquiv.comp_right_differentiable_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: simp only [← differentiableOn_univ, ← iso.comp_right_differentiableOn_iff, preimage_univ]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : F → G
⊢ Differentiable 𝕜 (f ∘ ⇑iso) ↔ Differentiable 𝕜 f
state_after: no goals
Theorem: SimpleGraph.simpleGraphOfStructure
File: Mathlib/ModelTheory/Graph.lean

tactic: ext
state_before: L : Language
α : Type w
V : Type w'
n : ℕ
G : SimpleGraph V
⊢ FirstOrder.Language.simpleGraphOfStructure V = G
state_after: case Adj.h.h.a
L : Language
α : Type w
V : Type w'
n : ℕ
G : SimpleGraph V
x✝¹ x✝ : V
⊢ (FirstOrder.Language.simpleGraphOfStructure V).Adj x✝¹ x✝ ↔ G.Adj x✝¹ x✝

tactic: rfl
state_before: case Adj.h.h.a
L : Language
α : Type w
V : Type w'
n : ℕ
G : SimpleGraph V
x✝¹ x✝ : V
⊢ (FirstOrder.Language.simpleGraphOfStructure V).Adj x✝¹ x✝ ↔ G.Adj x✝¹ x✝
state_after: no goals
Theorem: AlgebraicGeometry.ProjIsoSpecTopComponent.toSpec.image_basicOpen_eq_basicOpen
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

tactic: rw [mul_comm]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
a : A
i : ℕ
⊢ f ^ i ∈ 𝒜 (m * i)
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
a : A
i : ℕ
⊢ f ^ i ∈ 𝒜 (i * m)

tactic: exact SetLike.pow_mem_graded _ f_deg
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
a : A
i : ℕ
⊢ f ^ i ∈ 𝒜 (i * m)
state_after: no goals

tactic: rw [Opens.carrier_eq_coe, toSpec_preimage_basicOpen, ProjectiveSpectrum.basicOpen_pow 𝒜 _ m hm]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
a : A
i : ℕ
⊢ Subtype.val ⁻¹' ↑(pbo ↑(((decompose 𝒜) a) i)) =
    ⇑(toSpec 𝒜 f) ⁻¹'
      (sbo
          HomogeneousLocalization.mk
            { deg := m * i, num := ⟨↑(((decompose 𝒜) a) i) ^ m, ⋯⟩, den := ⟨f ^ i, ⋯⟩, den_mem := ⋯ }).carrier
state_after: no goals
Theorem: Quaternion.normSq_eq_norm_mul_self
File: Mathlib/Analysis/Quaternion.lean

tactic: rw [← inner_self, real_inner_self_eq_norm_mul_norm]
state_before: a : ℍ
⊢ normSq a = ‖a‖ * ‖a‖
state_after: no goals
Theorem: Int.bitwise_xor
File: Mathlib/Data/Int/Bitwise.lean

tactic: funext m n
state_before: ⊢ bitwise xor = Int.xor
state_after: case h.h
m n : ℤ
⊢ bitwise xor m n = m.xor n

tactic: cases' m with m m <;> cases' n with n n <;> try {rfl}
  <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, Bool.bne_eq_xor,
    cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq, Bool.false_xor,
    Bool.true_xor, Bool.and_false, Nat.land, Bool.not_true, ldiff,
    HOr.hOr, OrOp.or, Nat.lor, Int.xor, HXor.hXor, Xor.xor, Nat.xor]
state_before: case h.h
m n : ℤ
⊢ bitwise xor m n = m.xor n
state_after: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !xor x !y) m n = Nat.bitwise xor m n

case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise (fun x y => !xor (!x) y) m n = Nat.bitwise xor m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise (fun x y => xor (!x) !y) m n) = ↑(Nat.bitwise xor m n)

tactic: rfl
state_before: case h.h.ofNat.ofNat
m n : ℕ
⊢ bitwise xor (ofNat m) (ofNat n) = (ofNat m).xor (ofNat n)
state_after: no goals

tactic: congr
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !xor x !y) m n = Nat.bitwise xor m n
state_after: case h.h.ofNat.negSucc.e_f
m n : ℕ
⊢ (fun x y => !xor x !y) = xor

tactic: funext x y
state_before: case h.h.ofNat.negSucc.e_f
m n : ℕ
⊢ (fun x y => !xor x !y) = xor
state_after: case h.h.ofNat.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!xor x !y) = xor x y

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.ofNat.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!xor x !y) = xor x y
state_after: no goals

tactic: congr
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise (fun x y => !xor (!x) y) m n = Nat.bitwise xor m n
state_after: case h.h.negSucc.ofNat.e_f
m n : ℕ
⊢ (fun x y => !xor (!x) y) = xor

tactic: funext x y
state_before: case h.h.negSucc.ofNat.e_f
m n : ℕ
⊢ (fun x y => !xor (!x) y) = xor
state_after: case h.h.negSucc.ofNat.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!xor (!x) y) = xor x y

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!xor (!x) y) = xor x y
state_after: no goals

tactic: congr
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise (fun x y => xor (!x) !y) m n) = ↑(Nat.bitwise xor m n)
state_after: case h.h.negSucc.negSucc.e_a.e_f
m n : ℕ
⊢ (fun x y => xor (!x) !y) = xor

tactic: funext x y
state_before: case h.h.negSucc.negSucc.e_a.e_f
m n : ℕ
⊢ (fun x y => xor (!x) !y) = xor
state_after: case h.h.negSucc.negSucc.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (xor (!x) !y) = xor x y

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (xor (!x) !y) = xor x y
state_after: no goals