tasksource/leandojo huggingface dataset:
Theorem: Function.Injective.map_swap
File: Mathlib/Logic/Equiv/Basic.lean

tactic: conv_rhs => rw [Equiv.swap_apply_def]
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
⊢ f (↑(Equiv.swap x y) z) = ↑(Equiv.swap (f x) (f y)) (f z)

tactic: split_ifs with h₁ h₂
state_before: α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
⊢ f (↑(Equiv.swap x y) z) = if f z = f x then f y else if f z = f y then f x else f z

tactic: rw [hf h₁, Equiv.swap_apply_left]
state_before: case inl
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
h₁ : f z = f x
⊢ f (↑(Equiv.swap x y) z) = f y

tactic: rw [hf h₂, Equiv.swap_apply_right]
state_before: case inr.inl
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
h₁ : ¬f z = f x
h₂ : f z = f y
⊢ f (↑(Equiv.swap x y) z) = f x

tactic: rw [Equiv.swap_apply_of_ne_of_ne (mt (congr_arg f) h₁) (mt (congr_arg f) h₂)]
state_before: case inr.inr
α : Sort u_1
β : Sort u_2
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
f : α → β
hf : Injective f
x y z : α
h₁ : ¬f z = f x
h₂ : ¬f z = f y
⊢ f (↑(Equiv.swap x y) z) = f z
Theorem: Stream'.Seq.ge_stable
File: Mathlib/Data/Seq/Seq.lean

tactic: simp [s_nth_eq_some]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
aₙ : α
n m : ℕ
m_le_n : m ≤ n
s_nth_eq_some : get? s n = some aₙ
⊢ get? s n ≠ none
Theorem: Set.unbounded_le_inter_le
File: Mathlib/Order/Bounded.lean

tactic: rw [← not_bounded_iff, ← not_bounded_iff, not_iff_not]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Unbounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) ↔ Unbounded (fun x x_1 => x ≤ x_1) s

tactic: exact bounded_le_inter_le a
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) ↔ Bounded (fun x x_1 => x ≤ x_1) s
Theorem: Std.RBNode.balRight_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: unfold balRight
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ toList (balRight l v r) = toList l ++ v :: toList r

tactic: split <;> simp
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ toList
      (match r with
      | node red b y c => node red l v (node black b y c)
      | r =>
        match l with
        | node black a x b => balance1 (node red a x b) v r
        | node red a x (node black b y c) => node red (balance1 (setRed a) x b) y (node black c v r)
        | l => node red l v r) =
    toList l ++ v :: toList r

tactic: split <;> simp
state_before: case h_2
α : Type u_1
l : RBNode α
v : α
r l✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), r = node red a x b → False
⊢ toList
      (match l with
      | node black a x b => balance1 (node red a x b) v r
      | node red a x (node black b y c) => node red (balance1 (setRed a) x b) y (node black c v r)
      | l => node red l v r) =
    toList l ++ v :: toList r
Theorem: Set.apply_piecewise
File: Mathlib/Data/Set/Function.lean

tactic: by_cases hx : x ∈ s <;> simp [hx]
state_before: α : Type u_2
β : Type ?u.90308
γ : Type ?u.90311
ι : Sort ?u.90314
π : α → Type ?u.90319
δ : α → Sort u_3
s : Set α
f g : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ' : α → Sort u_1
h : (i : α) → δ i → δ' i
x : α
⊢ h x (piecewise s f g x) = piecewise s (fun x => h x (f x)) (fun x => h x (g x)) x
Theorem: Real.sqrtTwoAddSeries_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp
state_before: x : ℝ
⊢ sqrtTwoAddSeries 0 2 = sqrt (2 + sqrt 2)
Theorem: Set.univ_subtype
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type ?u.196879
γ : Type ?u.196882
ι : Sort ?u.196885
ι' : Sort ?u.196888
ι₂ : Sort ?u.196891
κ : ι → Sort ?u.196896
κ₁ : ι → Sort ?u.196901
κ₂ : ι → Sort ?u.196906
κ' : ι' → Sort ?u.196911
p : α → Prop
x✝ : Subtype p
x : α
h : p x
⊢ { val := x, property := h } ∈ univ ↔ { val := x, property := h } ∈ ⋃ (x : α) (h : p x), {{ val := x, property := h }}
Theorem: lt_geom
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: apply (monotone_mul_left_of_nonneg hc).seq_pos_lt_seq_of_lt_of_le hn _ h _
state_before: α : Type ?u.37075
β : Type ?u.37078
ι : Type ?u.37081
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ (k : ℕ), k < n → u (k + 1) < c * u k
⊢ u n < c ^ n * u 0

tactic: simp
state_before: α : Type ?u.37075
β : Type ?u.37078
ι : Type ?u.37081
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ (k : ℕ), k < n → u (k + 1) < c * u k
⊢ u 0 ≤ c ^ 0 * u 0

tactic: simp [_root_.pow_succ, mul_assoc, le_refl]
state_before: α : Type ?u.37075
β : Type ?u.37078
ι : Type ?u.37081
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
hn : 0 < n
h : ∀ (k : ℕ), k < n → u (k + 1) < c * u k
⊢ ∀ (k : ℕ), k < n → c * (c ^ k * u 0) ≤ c ^ (k + 1) * u 0
Theorem: orthogonalProjection_mem_subspace_orthogonalComplement_eq_zero
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: ext
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.803050
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
v : E
hv : v ∈ Kᗮ
⊢ ↑(orthogonalProjection K) v = 0

tactic: convert eq_orthogonalProjection_of_mem_orthogonal (K := K) _ _ <;> simp [hv]
state_before: case a
𝕜 : Type u_2
E : Type u_1
F : Type ?u.803050
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ K }
v : E
hv : v ∈ Kᗮ
⊢ ↑(↑(orthogonalProjection K) v) = ↑0
Theorem: Vector3.insert_fz
File: Mathlib/Data/Vector3.lean

tactic: refine' funext fun j => j.cases' _ _ <;> intros <;> rfl
state_before: α : Type u_1
m n : ℕ
a : α
v : Vector3 α n
⊢ insert a v fz = a :: v
Theorem: boundedSpace_subtype_iff
File: Mathlib/Topology/Bornology/Constructions.lean

tactic: rw [boundedSpace_induced_iff, Subtype.range_coe_subtype]
state_before: α : Type u_1
β : Type ?u.107189
ι : Type ?u.107192
π : ι → Type ?u.107197
inst✝³ : Fintype ι
inst✝² : Bornology α
inst✝¹ : Bornology β
inst✝ : (i : ι) → Bornology (π i)
p : α → Prop
⊢ BoundedSpace (Subtype p) ↔ IsBounded {x | p x}
Theorem: IsLocalization.mul_add_inv_left
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [mul_comm, ← one_mul z₁, ← Units.inv_mul (IsUnit.liftRight (g.toMonoidHom.restrict M) h y),
  mul_assoc, ← mul_add, Units.inv_mul_eq_iff_eq_mul, Units.inv_mul_cancel_left,
  IsUnit.coe_liftRight]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type ?u.919061
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_2
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
h : ∀ (y : { x // x ∈ M }), IsUnit (↑g ↑y)
y : { x // x ∈ M }
w z₁ z₂ : P
⊢ w * ↑(↑(IsUnit.liftRight (MonoidHom.restrict (↑g) M) h) y)⁻¹ + z₁ = z₂ ↔ w + ↑g ↑y * z₁ = ↑g ↑y * z₂

tactic: simp [RingHom.toMonoidHom_eq_coe, MonoidHom.restrict_apply]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type ?u.919061
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_2
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
g : R →+* P
h : ∀ (y : { x // x ∈ M }), IsUnit (↑g ↑y)
y : { x // x ∈ M }
w z₁ z₂ : P
⊢ w + ↑(MonoidHom.restrict (↑g) M) y * z₁ = ↑(MonoidHom.restrict (↑g) M) y * z₂ ↔ w + ↑g ↑y * z₁ = ↑g ↑y * z₂
Theorem: MulAction.mem_orbit_self
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: simp [MulAction.one_smul]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : Monoid α
inst✝ : MulAction α β
b : β
⊢ (fun x => x • b) 1 = b
Theorem: QuotientGroup.mk_mul_of_mem
File: Mathlib/GroupTheory/Coset.lean

tactic: rwa [eq', mul_inv_rev, inv_mul_cancel_right, s.inv_mem_iff]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
a✝ b a : α
hb : b ∈ s
⊢ ↑(a * b) = ↑a
Theorem: deriv_const_add
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simp only [deriv, fderiv_const_add]
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 𝕜
c : F
⊢ deriv (fun y => c + f y) x = deriv f x
Theorem: Real.exists_rat_pow_btwn
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: obtain ⟨q₂, hx₂, hy₂⟩ := exists_rat_btwn (max_lt h hy)
state_before: z x✝ y✝ : ℝ
n : ℕ
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
hn : n ≠ 0
x y : α
h : x < y
hy : 0 < y
⊢ ∃ q, 0 < q ∧ x < ↑q ^ n ∧ ↑q ^ n < y

tactic: obtain ⟨q₁, hx₁, hq₁₂⟩ := exists_rat_btwn hx₂
state_before: case intro.intro
z x✝ y✝ : ℝ
n : ℕ
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
hn : n ≠ 0
x y : α
h : x < y
hy : 0 < y
q₂ : ℚ
hx₂ : max x 0 < ↑q₂
hy₂ : ↑q₂ < y
⊢ ∃ q, 0 < q ∧ x < ↑q ^ n ∧ ↑q ^ n < y

tactic: have : (0 : α) < q₂ := (le_max_right _ _).trans_lt hx₂
state_before: case intro.intro.intro.intro
z x✝ y✝ : ℝ
n : ℕ
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
hn : n ≠ 0
x y : α
h : x < y
hy : 0 < y
q₂ : ℚ
hx₂ : max x 0 < ↑q₂
hy₂ : ↑q₂ < y
q₁ : ℚ
hx₁ : max x 0 < ↑q₁
hq₁₂ : ↑q₁ < ↑q₂
⊢ ∃ q, 0 < q ∧ x < ↑q ^ n ∧ ↑q ^ n < y

tactic: norm_cast  at hq₁₂ this
state_before: case intro.intro.intro.intro
z x✝ y✝ : ℝ
n : ℕ
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
hn : n ≠ 0
x y : α
h : x < y
hy : 0 < y
q₂ : ℚ
hx₂ : max x 0 < ↑q₂
hy₂ : ↑q₂ < y
q₁ : ℚ
hx₁ : max x 0 < ↑q₁
hq₁₂ : ↑q₁ < ↑q₂
this : 0 < ↑q₂
⊢ ∃ q, 0 < q ∧ x < ↑q ^ n ∧ ↑q ^ n < y

tactic: obtain ⟨q, hq, hq₁, hq₂⟩ := exists_rat_pow_btwn_rat hn hq₁₂ this
state_before: case intro.intro.intro.intro
z x✝ y✝ : ℝ
n : ℕ
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
hn : n ≠ 0
x y : α
h : x < y
hy : 0 < y
q₂ : ℚ
hx₂ : max x 0 < ↑q₂
hy₂ : ↑q₂ < y
q₁ : ℚ
hx₁ : max x 0 < ↑q₁
hq₁₂ : q₁ < q₂
this : 0 < q₂
⊢ ∃ q, 0 < q ∧ x < ↑q ^ n ∧ ↑q ^ n < y

tactic: refine' ⟨q, hq, (le_max_left _ _).trans_lt <| hx₁.trans _, hy₂.trans' _⟩ <;> assumption_mod_cast
state_before: case intro.intro.intro.intro.intro.intro.intro
z x✝ y✝ : ℝ
n : ℕ
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
hn : n ≠ 0
x y : α
h : x < y
hy : 0 < y
q₂ : ℚ
hx₂ : max x 0 < ↑q₂
hy₂ : ↑q₂ < y
q₁ : ℚ
hx₁ : max x 0 < ↑q₁
hq₁₂ : q₁ < q₂
this : 0 < q₂
q : ℚ
hq : 0 < q
hq₁ : q₁ < q ^ n
hq₂ : q ^ n < q₂
⊢ ∃ q, 0 < q ∧ x < ↑q ^ n ∧ ↑q ^ n < y
Theorem: Balanced.subset_smul
File: Mathlib/Analysis/LocallyConvex/Basic.lean

tactic: refine' (subset_set_smul_iff₀ _).2 (hA a⁻¹ _)
state_before: 𝕜 : Type u_1
𝕝 : Type ?u.86571
E : Type u_2
ι : Sort ?u.86577
κ : ι → Sort ?u.86582
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedRing 𝕝
inst✝⁴ : NormedSpace 𝕜 𝕝
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : SMulWithZero 𝕝 E
inst✝ : IsScalarTower 𝕜 𝕝 E
s t u v A B : Set E
x : E
a b : 𝕜
hA : Balanced 𝕜 A
ha : 1 ≤ ‖a‖
⊢ A ⊆ a • A

tactic: rintro rfl
state_before: case refine'_1
𝕜 : Type u_1
𝕝 : Type ?u.86571
E : Type u_2
ι : Sort ?u.86577
κ : ι → Sort ?u.86582
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedRing 𝕝
inst✝⁴ : NormedSpace 𝕜 𝕝
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : SMulWithZero 𝕝 E
inst✝ : IsScalarTower 𝕜 𝕝 E
s t u v A B : Set E
x : E
a b : 𝕜
hA : Balanced 𝕜 A
ha : 1 ≤ ‖a‖
⊢ a ≠ 0

tactic: rw [norm_zero] at ha
state_before: case refine'_1
𝕜 : Type u_1
𝕝 : Type ?u.86571
E : Type u_2
ι : Sort ?u.86577
κ : ι → Sort ?u.86582
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedRing 𝕝
inst✝⁴ : NormedSpace 𝕜 𝕝
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : SMulWithZero 𝕝 E
inst✝ : IsScalarTower 𝕜 𝕝 E
s t u v A B : Set E
x : E
b : 𝕜
hA : Balanced 𝕜 A
ha : 1 ≤ ‖0‖
⊢ False

tactic: exact zero_lt_one.not_le ha
state_before: case refine'_1
𝕜 : Type u_1
𝕝 : Type ?u.86571
E : Type u_2
ι : Sort ?u.86577
κ : ι → Sort ?u.86582
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedRing 𝕝
inst✝⁴ : NormedSpace 𝕜 𝕝
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : SMulWithZero 𝕝 E
inst✝ : IsScalarTower 𝕜 𝕝 E
s t u v A B : Set E
x : E
b : 𝕜
hA : Balanced 𝕜 A
ha : 1 ≤ 0
⊢ False

tactic: rw [norm_inv]
state_before: case refine'_2
𝕜 : Type u_1
𝕝 : Type ?u.86571
E : Type u_2
ι : Sort ?u.86577
κ : ι → Sort ?u.86582
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedRing 𝕝
inst✝⁴ : NormedSpace 𝕜 𝕝
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : SMulWithZero 𝕝 E
inst✝ : IsScalarTower 𝕜 𝕝 E
s t u v A B : Set E
x : E
a b : 𝕜
hA : Balanced 𝕜 A
ha : 1 ≤ ‖a‖
⊢ ‖a⁻¹‖ ≤ 1

tactic: exact inv_le_one ha
state_before: case refine'_2
𝕜 : Type u_1
𝕝 : Type ?u.86571
E : Type u_2
ι : Sort ?u.86577
κ : ι → Sort ?u.86582
inst✝⁶ : NormedField 𝕜
inst✝⁵ : NormedRing 𝕝
inst✝⁴ : NormedSpace 𝕜 𝕝
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : SMulWithZero 𝕝 E
inst✝ : IsScalarTower 𝕜 𝕝 E
s t u v A B : Set E
x : E
a b : 𝕜
hA : Balanced 𝕜 A
ha : 1 ≤ ‖a‖
⊢ ‖a‖⁻¹ ≤ 1
Theorem: ProbabilityTheory.cond_empty
File: Mathlib/Probability/ConditionalProbability.lean

tactic: simp [cond]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t : Set Ω
⊢ μ[|∅] = 0
Theorem: Matrix.vecMul_one
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.905407
m : Type u_1
n : Type ?u.905413
o : Type ?u.905416
m' : o → Type ?u.905421
n' : o → Type ?u.905426
R : Type ?u.905429
S : Type ?u.905432
α : Type v
β : Type w
γ : Type ?u.905439
inst✝³ : NonAssocSemiring α
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : DecidableEq m
v : m → α
⊢ vecMul v 1 = v

tactic: rw [← diagonal_one, vecMul_diagonal, mul_one]
state_before: case h
l : Type ?u.905407
m : Type u_1
n : Type ?u.905413
o : Type ?u.905416
m' : o → Type ?u.905421
n' : o → Type ?u.905426
R : Type ?u.905429
S : Type ?u.905432
α : Type v
β : Type w
γ : Type ?u.905439
inst✝³ : NonAssocSemiring α
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : DecidableEq m
v : m → α
x✝ : m
⊢ vecMul v 1 x✝ = v x✝
Theorem: Primrec.list_map
File: Mathlib/Computability/Primrec.lean

tactic: induction f a <;> simp [*]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.311399
σ : Type u_3
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → List β
g : α → β → σ
hf : Primrec f
hg : Primrec₂ g
a : α
⊢ List.foldr (fun b s => g (a, b, s).fst (a, b, s).snd.fst :: (a, b, s).snd.snd) [] (f a) = List.map (g a) (f a)
Theorem: Rat.divInt_num_den
File: Std/Data/Rat/Lemmas.lean

tactic: rcases Int.eq_nat_or_neg d with ⟨_, rfl | rfl⟩ <;>
  simp_all [divInt_neg', Int.ofNat_eq_zero, Int.neg_eq_zero]
state_before: d n n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
z : d ≠ 0
h : n /. d = mk' n' d'
⊢ ∃ m, m ≠ 0 ∧ n = n' * m ∧ d = ↑d' * m

tactic: have ⟨m, h₁, h₂⟩ := mkRat_num_den z h
state_before: case intro.inl
n n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
w✝ : Nat
z : ¬w✝ = 0
h : mkRat n w✝ = mk' n' d'
⊢ ∃ m, ¬m = 0 ∧ n = n' * m ∧ ↑w✝ = ↑d' * m

tactic: exists m
state_before: case intro.inl
n n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
w✝ : Nat
z : ¬w✝ = 0
h : mkRat n w✝ = mk' n' d'
m : Nat
h₁ : m ≠ 0
h₂ : n = n' * ↑m ∧ w✝ = d' * m
⊢ ∃ m, ¬m = 0 ∧ n = n' * m ∧ ↑w✝ = ↑d' * m

tactic: simp [Int.ofNat_eq_zero, Int.ofNat_mul, h₁, h₂]
state_before: case intro.inl
n n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
w✝ : Nat
z : ¬w✝ = 0
h : mkRat n w✝ = mk' n' d'
m : Nat
h₁ : m ≠ 0
h₂ : n = n' * ↑m ∧ w✝ = d' * m
⊢ ¬↑m = 0 ∧ n = n' * ↑m ∧ ↑w✝ = ↑d' * ↑m

tactic: have ⟨m, h₁, h₂⟩ := mkRat_num_den z h
state_before: case intro.inr
n n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
w✝ : Nat
z : ¬w✝ = 0
h : mkRat (-n) w✝ = mk' n' d'
⊢ ∃ m, ¬m = 0 ∧ n = n' * m ∧ -↑w✝ = ↑d' * m

tactic: exists -m
state_before: case intro.inr
n n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
w✝ : Nat
z : ¬w✝ = 0
h : mkRat (-n) w✝ = mk' n' d'
m : Nat
h₁ : m ≠ 0
h₂ : -n = n' * ↑m ∧ w✝ = d' * m
⊢ ∃ m, ¬m = 0 ∧ n = n' * m ∧ -↑w✝ = ↑d' * m

tactic: rw [← Int.neg_inj, Int.neg_neg] at h₂
state_before: case intro.inr
n n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
w✝ : Nat
z : ¬w✝ = 0
h : mkRat (-n) w✝ = mk' n' d'
m : Nat
h₁ : m ≠ 0
h₂ : -n = n' * ↑m ∧ w✝ = d' * m
⊢ ¬-↑m = 0 ∧ n = n' * -↑m ∧ -↑w✝ = ↑d' * -↑m

tactic: simp [Int.ofNat_eq_zero, Int.ofNat_mul, h₁, h₂, Int.mul_neg, Int.neg_eq_zero]
state_before: case intro.inr
n n' : Int
d' : Nat
z' : d' ≠ 0
c : Nat.coprime (Int.natAbs n') d'
w✝ : Nat
z : ¬w✝ = 0
h : mkRat (-n) w✝ = mk' n' d'
m : Nat
h₁ : m ≠ 0
h₂ : n = -(n' * ↑m) ∧ w✝ = d' * m
⊢ ¬-↑m = 0 ∧ n = n' * -↑m ∧ -↑w✝ = ↑d' * -↑m
Theorem: Submodule.fg_span
File: Mathlib/RingTheory/Finiteness.lean

tactic: rw [hs.coe_toFinset]
state_before: R : Type u_2
M : Type u_1
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set M
hs : Set.Finite s
⊢ span R ↑(Finite.toFinset hs) = span R s
Theorem: AffineIsometryEquiv.range_eq_univ
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: rw [← coe_toIsometryEquiv]
state_before: 𝕜 : Type u_1
V : Type u_2
V₁ : Type ?u.522448
V₂ : Type u_3
V₃ : Type ?u.522454
V₄ : Type ?u.522457
P₁ : Type ?u.522460
P : Type u_4
P₂ : Type u_5
P₃ : Type ?u.522469
P₄ : Type ?u.522472
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
e✝ e : P ≃ᵃⁱ[𝕜] P₂
⊢ range ↑e = univ

tactic: exact IsometryEquiv.range_eq_univ _
state_before: 𝕜 : Type u_1
V : Type u_2
V₁ : Type ?u.522448
V₂ : Type u_3
V₃ : Type ?u.522454
V₄ : Type ?u.522457
P₁ : Type ?u.522460
P : Type u_4
P₂ : Type u_5
P₃ : Type ?u.522469
P₄ : Type ?u.522472
inst✝²⁰ : NormedField 𝕜
inst✝¹⁹ : SeminormedAddCommGroup V
inst✝¹⁸ : SeminormedAddCommGroup V₁
inst✝¹⁷ : SeminormedAddCommGroup V₂
inst✝¹⁶ : SeminormedAddCommGroup V₃
inst✝¹⁵ : SeminormedAddCommGroup V₄
inst✝¹⁴ : NormedSpace 𝕜 V
inst✝¹³ : NormedSpace 𝕜 V₁
inst✝¹² : NormedSpace 𝕜 V₂
inst✝¹¹ : NormedSpace 𝕜 V₃
inst✝¹⁰ : NormedSpace 𝕜 V₄
inst✝⁹ : PseudoMetricSpace P
inst✝⁸ : MetricSpace P₁
inst✝⁷ : PseudoMetricSpace P₂
inst✝⁶ : PseudoMetricSpace P₃
inst✝⁵ : PseudoMetricSpace P₄
inst✝⁴ : NormedAddTorsor V P
inst✝³ : NormedAddTorsor V₁ P₁
inst✝² : NormedAddTorsor V₂ P₂
inst✝¹ : NormedAddTorsor V₃ P₃
inst✝ : NormedAddTorsor V₄ P₄
e✝ e : P ≃ᵃⁱ[𝕜] P₂
⊢ range ↑(toIsometryEquiv e) = univ
Theorem: intervalIntegral.inv_smul_integral_comp_div_add
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_div_add]
state_before: ι : Type ?u.14895046
𝕜 : Type ?u.14895049
E : Type u_1
F : Type ?u.14895055
A : Type ?u.14895058
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d✝ : ℝ
f : ℝ → E
c d : ℝ
⊢ (c⁻¹ • ∫ (x : ℝ) in a..b, f (x / c + d)) = ∫ (x : ℝ) in a / c + d..b / c + d, f x
Theorem: Polynomial.eval₂_monomial
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp [eval₂_eq_sum]
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]
inst✝ : Semiring S
f : R →+* S
x : S
n : ℕ
r : R
⊢ eval₂ f x (↑(monomial n) r) = ↑f r * x ^ n
Theorem: WithTop.top_mul_top
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: simp [mul_def]
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Zero α
inst✝ : Mul α
⊢ ⊤ * ⊤ = ⊤

tactic: rfl
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Zero α
inst✝ : Mul α
⊢ Option.map₂ (fun x x_1 => x * x_1) ⊤ ⊤ = ⊤
Theorem: le_of_span_le_span
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: have :=
  eq_of_linearIndependent_of_span_subtype (hl.mono (Set.union_subset hsu htu))
    (Set.subset_union_right _ _) (Set.union_subset (Set.Subset.trans subset_span hst) subset_span)
state_before: ι : Type u'
ι' : Type ?u.1166078
R : Type u_1
K : Type ?u.1166084
M : Type u_2
M' : Type ?u.1166090
M'' : Type ?u.1166093
V : Type u
V' : Type ?u.1166098
v : ι → M
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
a b : R
x y : M
inst✝ : Nontrivial R
s t u : Set M
hl : LinearIndependent R Subtype.val
hsu : s ⊆ u
htu : t ⊆ u
hst : span R s ≤ span R t
⊢ s ⊆ t

tactic: rw [← this]
state_before: ι : Type u'
ι' : Type ?u.1166078
R : Type u_1
K : Type ?u.1166084
M : Type u_2
M' : Type ?u.1166090
M'' : Type ?u.1166093
V : Type u
V' : Type ?u.1166098
v : ι → M
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
a b : R
x y : M
inst✝ : Nontrivial R
s t u : Set M
hl : LinearIndependent R Subtype.val
hsu : s ⊆ u
htu : t ⊆ u
hst : span R s ≤ span R t
this : s ∪ t = t
⊢ s ⊆ t

tactic: apply Set.subset_union_left
state_before: ι : Type u'
ι' : Type ?u.1166078
R : Type u_1
K : Type ?u.1166084
M : Type u_2
M' : Type ?u.1166090
M'' : Type ?u.1166093
V : Type u
V' : Type ?u.1166098
v : ι → M
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
a b : R
x y : M
inst✝ : Nontrivial R
s t u : Set M
hl : LinearIndependent R Subtype.val
hsu : s ⊆ u
htu : t ⊆ u
hst : span R s ≤ span R t
this : s ∪ t = t
⊢ s ⊆ s ∪ t
Theorem: ascending_central_series_le_upper
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: intro x hx
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
n : ℕ
⊢ H (n + 1) ≤ upperCentralSeries G (n + 1)

tactic: rw [mem_upperCentralSeries_succ_iff]
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
n : ℕ
x : G
hx : x ∈ H (n + 1)
⊢ x ∈ upperCentralSeries G (n + 1)

tactic: exact fun y => ascending_central_series_le_upper H hH n (hH.2 x n hx y)
state_before: G : Type u_1
inst✝¹ : Group G
H✝ : Subgroup G
inst✝ : Normal H✝
H : ℕ → Subgroup G
hH : IsAscendingCentralSeries H
n : ℕ
x : G
hx : x ∈ H (n + 1)
⊢ ∀ (y : G), x * y * x⁻¹ * y⁻¹ ∈ upperCentralSeries G n
Theorem: Cardinal.not_irreducible_of_aleph0_le
File: Mathlib/SetTheory/Cardinal/Divisibility.lean

tactic: rw [irreducible_iff, not_and_or]
state_before: a b : Cardinal
n m : ℕ
ha : ℵ₀ ≤ a
⊢ ¬Irreducible a

tactic: refine' Or.inr fun h => _
state_before: a b : Cardinal
n m : ℕ
ha : ℵ₀ ≤ a
⊢ ¬¬IsUnit a ∨ ¬∀ (a_1 b : Cardinal), a = a_1 * b → IsUnit a_1 ∨ IsUnit b

tactic: simpa [mul_aleph0_eq ha, isUnit_iff, (one_lt_aleph0.trans_le ha).ne', one_lt_aleph0.ne'] using
  h a ℵ₀
state_before: a b : Cardinal
n m : ℕ
ha : ℵ₀ ≤ a
h : ∀ (a_1 b : Cardinal), a = a_1 * b → IsUnit a_1 ∨ IsUnit b
⊢ False
Theorem: CategoryTheory.Adjunction.strongEpi_map_of_strongEpi
File: Mathlib/CategoryTheory/Functor/EpiMono.lean

tactic: intro
state_before: C : Type u_3
D : Type u_4
inst✝² : Category C
inst✝¹ : Category D
F : C ⥤ D
F' : D ⥤ C
A B : C
adj : F ⊣ F'
f : A ⟶ B
h₁ : Functor.PreservesMonomorphisms F'
h₂ : Functor.PreservesEpimorphisms F
inst✝ : StrongEpi f
X Y : D
Z : X ⟶ Y
⊢ ∀ [inst : Mono Z], HasLiftingProperty (F.map f) Z

tactic: rw [adj.hasLiftingProperty_iff]
state_before: C : Type u_3
D : Type u_4
inst✝³ : Category C
inst✝² : Category D
F : C ⥤ D
F' : D ⥤ C
A B : C
adj : F ⊣ F'
f : A ⟶ B
h₁ : Functor.PreservesMonomorphisms F'
h₂ : Functor.PreservesEpimorphisms F
inst✝¹ : StrongEpi f
X Y : D
Z : X ⟶ Y
inst✝ : Mono Z
⊢ HasLiftingProperty (F.map f) Z

tactic: infer_instance
state_before: C : Type u_3
D : Type u_4
inst✝³ : Category C
inst✝² : Category D
F : C ⥤ D
F' : D ⥤ C
A B : C
adj : F ⊣ F'
f : A ⟶ B
h₁ : Functor.PreservesMonomorphisms F'
h₂ : Functor.PreservesEpimorphisms F
inst✝¹ : StrongEpi f
X Y : D
Z : X ⟶ Y
inst✝ : Mono Z
⊢ HasLiftingProperty f (F'.map Z)
Theorem: List.perm_append_comm
File: Mathlib/Data/List/Perm.lean

tactic: simp
state_before: α : Type uu
β : Type vv
l₁ l₂✝ l₂ : List α
⊢ [] ++ l₂ ~ l₂ ++ []