tasksource/leandojo huggingface dataset:
Theorem: QuaternionAlgebra.Basis.k_mul_k
File: Mathlib/Algebra/QuaternionBasis.lean

tactic: rw [← i_mul_j, mul_assoc, ← mul_assoc q.j _ _, j_mul_i, ← i_mul_j, ← mul_assoc, mul_neg, ←
  mul_assoc, i_mul_i, smul_mul_assoc, one_mul, neg_mul, smul_mul_assoc, j_mul_j, smul_smul]
state_before: R : Type u_2
A : Type u_1
B : Type ?u.34759
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
⊢ q.k * q.k = -((c₁ * c₂) • 1)
Theorem: MeasureTheory.lintegral_mono'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral, lintegral]
state_before: α : Type u_1
β : Type ?u.70000
γ : Type ?u.70003
δ : Type ?u.70006
m✝ : MeasurableSpace α
μ✝ ν✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
hμν : μ ≤ ν
f g : α → ℝ≥0∞
hfg : f ≤ g
⊢ (∫⁻ (a : α), f a ∂μ) ≤ ∫⁻ (a : α), g a ∂ν

tactic: exact iSup_mono fun φ => iSup_mono' fun hφ => ⟨le_trans hφ hfg, lintegral_mono (le_refl φ) hμν⟩
state_before: α : Type u_1
β : Type ?u.70000
γ : Type ?u.70003
δ : Type ?u.70006
m✝ : MeasurableSpace α
μ✝ ν✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
hμν : μ ≤ ν
f g : α → ℝ≥0∞
hfg : f ≤ g
⊢ (⨆ (g : α →ₛ ℝ≥0∞) (_ : ↑g ≤ fun a => f a), SimpleFunc.lintegral g μ) ≤
    ⨆ (g_1 : α →ₛ ℝ≥0∞) (_ : ↑g_1 ≤ fun a => g a), SimpleFunc.lintegral g_1 ν
Theorem: algebraicIndependent_empty_iff
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: simp
state_before: ι : Type ?u.509206
ι' : Type ?u.509209
R : Type u_2
K : Type ?u.509215
A : Type u_1
A' : Type ?u.509221
A'' : Type ?u.509224
V : Type u
V' : Type ?u.509229
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
⊢ AlgebraicIndependent R Subtype.val ↔ Injective ↑(algebraMap R A)
Theorem: eq_mul_of_inv_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h.symm, mul_inv_cancel_left]
state_before: α : Type ?u.51956
β : Type ?u.51959
G : Type u_1
inst✝ : Group G
a b c d : G
h : b⁻¹ * a = c
⊢ a = b * c
Theorem: derivWithin_zero_of_not_differentiableWithinAt
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: unfold derivWithin
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 L₁ L₂ : Filter 𝕜
h : ¬DifferentiableWithinAt 𝕜 f s x
⊢ derivWithin f s x = 0

tactic: rw [fderivWithin_zero_of_not_differentiableWithinAt h]
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 L₁ L₂ : Filter 𝕜
h : ¬DifferentiableWithinAt 𝕜 f s x
⊢ ↑(fderivWithin 𝕜 f s x) 1 = 0

tactic: simp
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 L₁ L₂ : Filter 𝕜
h : ¬DifferentiableWithinAt 𝕜 f s x
⊢ ↑0 1 = 0
Theorem: Real.Angle.sign_two_zsmul_eq_sign_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [two_zsmul, ← two_nsmul, sign_two_nsmul_eq_sign_iff]
state_before: θ : Angle
⊢ sign (2 • θ) = sign θ ↔ θ = ↑π ∨ abs (toReal θ) < π / 2
Theorem: Real.volume_Icc
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp [volume_val]
state_before: ι : Type ?u.119068
inst✝ : Fintype ι
a b : ℝ
⊢ ↑↑volume (Icc a b) = ofReal (b - a)
Theorem: Nat.Ico_insert_succ_left
File: Mathlib/Data/Nat/Interval.lean

tactic: rw [Ico_succ_left, ← Ioo_insert_left h]
state_before: a b c : ℕ
h : a < b
⊢ insert a (Ico (succ a) b) = Ico a b
Theorem: quasilinearOn_iff_mem_uIcc
File: Mathlib/Analysis/Convex/Quasiconvex.lean

tactic: rw [QuasilinearOn, quasiconvexOn_iff_le_max, quasiconcaveOn_iff_min_le, and_and_and_comm,
  and_self_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.12946
β : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrderedAddCommMonoid β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
⊢ QuasilinearOn 𝕜 s f ↔
    Convex 𝕜 s ∧
      ∀ ⦃x : E⦄,
        x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → f (a • x + b • y) ∈ uIcc (f x) (f y)

tactic: apply and_congr_right'
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.12946
β : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrderedAddCommMonoid β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
⊢ (Convex 𝕜 s ∧
      (∀ ⦃x : E⦄,
          x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → f (a • x + b • y) ≤ max (f x) (f y)) ∧
        ∀ ⦃x : E⦄,
          x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → min (f x) (f y) ≤ f (a • x + b • y)) ↔
    Convex 𝕜 s ∧
      ∀ ⦃x : E⦄,
        x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → f (a • x + b • y) ∈ uIcc (f x) (f y)

tactic: simp_rw [← forall_and, ← Icc_min_max, mem_Icc, and_comm]
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type ?u.12946
β : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : LinearOrderedAddCommMonoid β
inst✝ : SMul 𝕜 E
s : Set E
f g : E → β
⊢ ((∀ ⦃x : E⦄,
        x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → f (a • x + b • y) ≤ max (f x) (f y)) ∧
      ∀ ⦃x : E⦄,
        x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → min (f x) (f y) ≤ f (a • x + b • y)) ↔
    ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → f (a • x + b • y) ∈ uIcc (f x) (f y)
Theorem: ENNReal.mul_sSup
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp only [sSup_eq_iSup, mul_iSup]
state_before: α : Type ?u.155493
β : Type ?u.155496
γ : Type ?u.155499
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ s : Set ℝ≥0∞
a : ℝ≥0∞
⊢ a * sSup s = ⨆ (i : ℝ≥0∞) (_ : i ∈ s), a * i
Theorem: Cardinal.one_le_iff_pos
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← succ_zero, succ_le_iff]
state_before: α β : Type u
c : Cardinal
⊢ 1 ≤ c ↔ 0 < c
Theorem: TensorProduct.LieModule.liftLie_apply
File: Mathlib/Algebra/Lie/TensorProduct.lean

tactic: simp only [coe_liftLie_eq_lift_coe, LieModuleHom.coe_toLinearMap, lift_apply]
state_before: R : Type u
inst✝¹⁸ : CommRing R
L : Type v
M : Type w
N : Type w₁
P : Type w₂
Q : Type w₃
inst✝¹⁷ : LieRing L
inst✝¹⁶ : LieAlgebra R L
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
inst✝¹¹ : AddCommGroup N
inst✝¹⁰ : Module R N
inst✝⁹ : LieRingModule L N
inst✝⁸ : LieModule R L N
inst✝⁷ : AddCommGroup P
inst✝⁶ : Module R P
inst✝⁵ : LieRingModule L P
inst✝⁴ : LieModule R L P
inst✝³ : AddCommGroup Q
inst✝² : Module R Q
inst✝¹ : LieRingModule L Q
inst✝ : LieModule R L Q
f : M →ₗ⁅R,L⁆ N →ₗ[R] P
m : M
n : N
⊢ ↑(↑(liftLie R L M N P) f) (m ⊗ₜ[R] n) = ↑(↑f m) n
Theorem: EuclideanGeometry.dist_eq_add_dist_of_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: rw [dist_eq_norm_vsub V, dist_eq_norm_vsub V, dist_eq_norm_vsub V, ← vsub_sub_vsub_cancel_right]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
⊢ dist p1 p3 = dist p1 p2 + dist p3 p2

tactic: exact norm_sub_eq_add_norm_of_angle_eq_pi h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
⊢ ‖p1 -ᵥ ?p3 - (p3 -ᵥ ?p3)‖ = ‖p1 -ᵥ p2‖ + ‖p3 -ᵥ p2‖

case p3
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : ∠ p1 p2 p3 = π
⊢ P
Theorem: Polynomial.degree_C_mul_X
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simpa only [pow_one] using degree_C_mul_X_pow 1 ha
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
ha : a ≠ 0
⊢ degree (↑C a * X) = 1
Theorem: Int.ediv_mul_cancel_of_emod_eq_zero
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, mul_ediv_cancel_of_emod_eq_zero H]
state_before: a b : Int
H : a % b = 0
⊢ a / b * b = a
Theorem: Stream'.WSeq.flatten_think
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [flatten, think]
state_before: α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
⊢ Seq.destruct (flatten (Computation.think c)) = some (none, flatten c)
Theorem: Filter.HasBasis.eq_bot_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [not_exists, not_and, nonempty_iff_ne_empty]
state_before: α : Type u_1
β : Type ?u.20912
γ : Type ?u.20915
ι : Sort u_2
ι' : Sort ?u.20921
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : HasBasis l p s
⊢ (∀ {i : ι}, p i → Set.Nonempty (s i)) ↔ ¬∃ i, p i ∧ s i = ∅
Theorem: Stream'.WSeq.mem_of_mem_tail
File: Mathlib/Data/Seq/WSeq.lean

tactic: intro h
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
⊢ a ∈ tail s → a ∈ s

tactic: have := h
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
h : a ∈ tail s
⊢ a ∈ s

tactic: cases' h with n e
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
h this : a ∈ tail s
⊢ a ∈ s

tactic: revert s
state_before: case intro
α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
this : a ∈ tail s
n : ℕ
e : (fun b => some (some a) = b) (nth (↑(tail s)) n)
⊢ a ∈ s

tactic: simp [Stream'.nth]
state_before: case intro
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : WSeq α}, a ∈ tail s → (fun b => some (some a) = b) (nth (↑(tail s)) n) → a ∈ s

tactic: induction' n with n IH <;> intro s <;> induction' s using WSeq.recOn with x s s <;>
  simp <;> intro m e <;>
  injections
state_before: case intro
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : WSeq α}, a ∈ tail s → some (some a) = ↑(tail s) n → a ∈ s

tactic: exact Or.inr m
state_before: case intro.zero.h2
α : Type u
β : Type v
γ : Type w
a x : α
s : WSeq α
m : a ∈ s
e : some (some a) = ↑s 0
⊢ a = x ∨ a ∈ s

tactic: exact Or.inr m
state_before: case intro.succ.h2
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, a ∈ tail s → some (some a) = ↑(tail s) n → a ∈ s
x : α
s : WSeq α
m : a ∈ s
e : some (some a) = ↑s (Nat.succ n)
⊢ a = x ∨ a ∈ s

tactic: apply IH m
state_before: case intro.succ.h3
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, a ∈ tail s → some (some a) = ↑(tail s) n → a ∈ s
s : WSeq α
m : a ∈ tail s
e : some (some a) = ↑(think (tail s)) (Nat.succ n)
⊢ a ∈ s

tactic: rw [e]
state_before: case intro.succ.h3
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, a ∈ tail s → some (some a) = ↑(tail s) n → a ∈ s
s : WSeq α
m : a ∈ tail s
e : some (some a) = ↑(think (tail s)) (Nat.succ n)
⊢ some (some a) = ↑(tail s) n

tactic: cases tail s
state_before: case intro.succ.h3
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, a ∈ tail s → some (some a) = ↑(tail s) n → a ∈ s
s : WSeq α
m : a ∈ tail s
e : some (some a) = ↑(think (tail s)) (Nat.succ n)
⊢ ↑(think (tail s)) (Nat.succ n) = ↑(tail s) n

tactic: rfl
state_before: case intro.succ.h3.mk
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, a ∈ tail s → some (some a) = ↑(tail s) n → a ∈ s
s : WSeq α
m : a ∈ tail s
e : some (some a) = ↑(think (tail s)) (Nat.succ n)
val✝ : Stream' (Option (Option α))
property✝ : IsSeq val✝
⊢ ↑(think { val := val✝, property := property✝ }) (Nat.succ n) = ↑{ val := val✝, property := property✝ } n
Theorem: Subgroup.noncommPiCoprod_mulSingle
File: Mathlib/GroupTheory/NoncommPiCoprod.lean

tactic: apply MonoidHom.noncommPiCoprod_mulSingle
state_before: G : Type u_1
inst✝ : Group G
ι : Type u_2
hdec : DecidableEq ι
hfin : Fintype ι
H : ι → Subgroup G
f g : (i : ι) → { x // x ∈ H i }
hcomm : ∀ (i j : ι), i ≠ j → ∀ (x y : G), x ∈ H i → y ∈ H j → Commute x y
i : ι
y : { x // x ∈ H i }
⊢ ↑(noncommPiCoprod hcomm) (Pi.mulSingle i y) = ↑y
Theorem: CategoryTheory.Bicategory.pentagon_hom_hom_inv_hom_hom
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv ((α_ (f ≫ g) h i).hom ≫ (α_ f g (h ≫ i)).hom ≫ f ◁ (α_ g h i).inv) =
    inv ((α_ f g h).hom ▷ i ≫ (α_ f (g ≫ h) i).hom)
Theorem: Primrec.option_isSome
File: Mathlib/Computability/Primrec.lean

tactic: cases o <;> rfl
state_before: α : Type u_1
β : Type ?u.115916
γ : Type ?u.115919
δ : Type ?u.115922
σ : Type ?u.115925
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
o : Option α
⊢ (Option.casesOn (id o) false fun b => true) = Option.isSome o
Theorem: isReduced_iff_pow_one_lt
File: Mathlib/RingTheory/Nilpotent.lean

tactic: simp_rw [← zero_isRadical_iff, isRadical_iff_pow_one_lt k hk, zero_dvd_iff]
state_before: R S : Type u
x y : R
inst✝ : MonoidWithZero R
k : ℕ
hk : 1 < k
⊢ IsReduced R ↔ ∀ (x : R), x ^ k = 0 → x = 0
Theorem: inv_lt'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← inv_lt_inv_iff, inv_inv]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a⁻¹ < b ↔ b⁻¹ < a
Theorem: Equiv.coe_ofInjective_symm
File: Mathlib/Logic/Equiv/Set.lean

tactic: ext ⟨y, x, rfl⟩
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
hf : Injective f
⊢ ↑(ofInjective f hf).symm = rangeSplitting f

tactic: apply hf
state_before: case h.mk.intro
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
hf : Injective f
x : α
⊢ ↑(ofInjective f hf).symm { val := f x, property := (_ : ∃ y, f y = f x) } =
    rangeSplitting f { val := f x, property := (_ : ∃ y, f y = f x) }

tactic: simp [apply_rangeSplitting f]
state_before: case h.mk.intro.a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
hf : Injective f
x : α
⊢ f (↑(ofInjective f hf).symm { val := f x, property := (_ : ∃ y, f y = f x) }) =
    f (rangeSplitting f { val := f x, property := (_ : ∃ y, f y = f x) })
Theorem: Matrix.induction_on
File: Mathlib/Data/Matrix/Basis.lean

tactic: inhabit m
state_before: l : Type ?u.18908
m : Type u_1
n : Type u_2
R : Type ?u.18917
α : Type u_3
inst✝⁷ : DecidableEq l
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq n
inst✝⁴ : Semiring α
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Nonempty m
inst✝ : Nonempty n
P : Matrix m n α → Prop
M : Matrix m n α
h_add : ∀ (p q : Matrix m n α), P p → P q → P (p + q)
h_std_basis : ∀ (i : m) (j : n) (x : α), P (stdBasisMatrix i j x)
⊢ P 0

tactic: inhabit n
state_before: l : Type ?u.18908
m : Type u_1
n : Type u_2
R : Type ?u.18917
α : Type u_3
inst✝⁷ : DecidableEq l
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq n
inst✝⁴ : Semiring α
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Nonempty m
inst✝ : Nonempty n
P : Matrix m n α → Prop
M : Matrix m n α
h_add : ∀ (p q : Matrix m n α), P p → P q → P (p + q)
h_std_basis : ∀ (i : m) (j : n) (x : α), P (stdBasisMatrix i j x)
inhabited_h : Inhabited m
⊢ P 0

tactic: simpa using h_std_basis default default 0
state_before: l : Type ?u.18908
m : Type u_1
n : Type u_2
R : Type ?u.18917
α : Type u_3
inst✝⁷ : DecidableEq l
inst✝⁶ : DecidableEq m
inst✝⁵ : DecidableEq n
inst✝⁴ : Semiring α
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Nonempty m
inst✝ : Nonempty n
P : Matrix m n α → Prop
M : Matrix m n α
h_add : ∀ (p q : Matrix m n α), P p → P q → P (p + q)
h_std_basis : ∀ (i : m) (j : n) (x : α), P (stdBasisMatrix i j x)
inhabited_h✝ : Inhabited m
inhabited_h : Inhabited n
⊢ P 0
Theorem: MeasureTheory.OuterMeasure.isCaratheodory_iUnion_lt
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp [Nat.not_lt_zero]
state_before: α : Type u
m : OuterMeasure α
s✝ s₁ s₂ : Set α
s : ℕ → Set α
x✝ : ∀ (i : ℕ), i < 0 → IsCaratheodory m (s i)
⊢ IsCaratheodory m (⋃ (i : ℕ) (_ : i < 0), s i)

tactic: rw [biUnion_lt_succ]
state_before: α : Type u
m : OuterMeasure α
s✝ s₁ s₂ : Set α
s : ℕ → Set α
n : ℕ
h : ∀ (i : ℕ), i < n + 1 → IsCaratheodory m (s i)
⊢ IsCaratheodory m (⋃ (i : ℕ) (_ : i < n + 1), s i)

tactic: exact isCaratheodory_union m
        (isCaratheodory_iUnion_lt fun i hi => h i <| lt_of_lt_of_le hi <| Nat.le_succ _)
        (h n (le_refl (n + 1)))
state_before: α : Type u
m : OuterMeasure α
s✝ s₁ s₂ : Set α
s : ℕ → Set α
n : ℕ
h : ∀ (i : ℕ), i < n + 1 → IsCaratheodory m (s i)
⊢ IsCaratheodory m ((⋃ (k : ℕ) (_ : k < n), s k) ∪ s n)
Theorem: Set.SurjOn.inter_inter
File: Mathlib/Data/Set/Function.lean

tactic: intro y hy
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.41971
ι : Sort ?u.41974
π : α → Type ?u.41979
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
h₁ : SurjOn f s₁ t₁
h₂ : SurjOn f s₂ t₂
h : InjOn f (s₁ ∪ s₂)
⊢ SurjOn f (s₁ ∩ s₂) (t₁ ∩ t₂)

tactic: rcases h₁ hy.1 with ⟨x₁, hx₁, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.41971
ι : Sort ?u.41974
π : α → Type ?u.41979
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
h₁ : SurjOn f s₁ t₁
h₂ : SurjOn f s₂ t₂
h : InjOn f (s₁ ∪ s₂)
y : β
hy : y ∈ t₁ ∩ t₂
⊢ y ∈ f '' (s₁ ∩ s₂)

tactic: rcases h₂ hy.2 with ⟨x₂, hx₂, heq⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.41971
ι : Sort ?u.41974
π : α → Type ?u.41979
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
h₁ : SurjOn f s₁ t₁
h₂ : SurjOn f s₂ t₂
h : InjOn f (s₁ ∪ s₂)
x₁ : α
hx₁ : x₁ ∈ s₁
hy : f x₁ ∈ t₁ ∩ t₂
⊢ f x₁ ∈ f '' (s₁ ∩ s₂)

tactic: obtain rfl : x₁ = x₂ := h (Or.inl hx₁) (Or.inr hx₂) heq.symm
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.41971
ι : Sort ?u.41974
π : α → Type ?u.41979
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
h₁ : SurjOn f s₁ t₁
h₂ : SurjOn f s₂ t₂
h : InjOn f (s₁ ∪ s₂)
x₁ : α
hx₁ : x₁ ∈ s₁
hy : f x₁ ∈ t₁ ∩ t₂
x₂ : α
hx₂ : x₂ ∈ s₂
heq : f x₂ = f x₁
⊢ f x₁ ∈ f '' (s₁ ∩ s₂)

tactic: exact mem_image_of_mem f ⟨hx₁, hx₂⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.41971
ι : Sort ?u.41974
π : α → Type ?u.41979
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
h₁ : SurjOn f s₁ t₁
h₂ : SurjOn f s₂ t₂
h : InjOn f (s₁ ∪ s₂)
x₁ : α
hx₁ : x₁ ∈ s₁
hy : f x₁ ∈ t₁ ∩ t₂
hx₂ : x₁ ∈ s₂
heq : f x₁ = f x₁
⊢ f x₁ ∈ f '' (s₁ ∩ s₂)
Theorem: Filter.hasBasis_pi
File: Mathlib/Order/Filter/Pi.lean

tactic: simpa [Set.pi_def] using hasBasis_iInf' fun i => (h i).comap (eval i : (∀ j, α j) → α i)
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
ι' : ι → Type
s : (i : ι) → ι' i → Set (α i)
p : (i : ι) → ι' i → Prop
h : ∀ (i : ι), HasBasis (f i) (p i) (s i)
⊢ HasBasis (pi f) (fun If => Set.Finite If.fst ∧ ∀ (i : ι), i ∈ If.fst → p i (Prod.snd If i)) fun If =>
    Set.pi If.fst fun i => s i (Prod.snd If i)
Theorem: iUnion_Ico_add_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: refine' eq_univ_iff_forall.mpr fun b => mem_iUnion.mpr _
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a : α
⊢ (⋃ (n : ℤ), Ico (a + n • p) (a + (n + 1) • p)) = univ

tactic: rcases sub_toIcoDiv_zsmul_mem_Ico hp a b with ⟨hl, hr⟩
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
⊢ ∃ i, b ∈ Ico (a + i • p) (a + (i + 1) • p)

tactic: refine' ⟨toIcoDiv hp a b, ⟨le_sub_iff_add_le.mp hl, _⟩⟩
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a ≤ b - toIcoDiv hp a b • p
hr : b - toIcoDiv hp a b • p < a + p
⊢ ∃ i, b ∈ Ico (a + i • p) (a + (i + 1) • p)

tactic: rw [add_smul, one_smul, ← add_assoc]
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a ≤ b - toIcoDiv hp a b • p
hr : b - toIcoDiv hp a b • p < a + p
⊢ b < a + (toIcoDiv hp a b + 1) • p

tactic: convert sub_lt_iff_lt_add.mp hr using 1
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a ≤ b - toIcoDiv hp a b • p
hr : b - toIcoDiv hp a b • p < a + p
⊢ b < a + toIcoDiv hp a b • p + p

tactic: abel
state_before: case h.e'_4
α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a b : α
hl : a ≤ b - toIcoDiv hp a b • p
hr : b - toIcoDiv hp a b • p < a + p
⊢ a + toIcoDiv hp a b • p + p = a + p + toIcoDiv hp a b • p
Theorem: List.perm_lookupAll
File: Mathlib/Data/List/Sigma.lean

tactic: simp [lookupAll_eq_dlookup, nd₁, nd₂, perm_dlookup a nd₁ nd₂ p]
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : NodupKeys l₁
nd₂ : NodupKeys l₂
p : l₁ ~ l₂
⊢ lookupAll a l₁ = lookupAll a l₂
Theorem: intervalIntegral.integral_smul_const
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp only [intervalIntegral_eq_integral_uIoc, integral_smul_const, smul_assoc]
state_before: ι : Type ?u.13121336
𝕜✝ : Type ?u.13121339
E : Type u_2
F : Type ?u.13121345
A : Type ?u.13121348
inst✝⁴ : NormedAddCommGroup E
inst✝³ : CompleteSpace E
inst✝² : NormedSpace ℝ E
a b : ℝ
f✝ g : ℝ → E
μ : MeasureTheory.Measure ℝ
𝕜 : Type u_1
inst✝¹ : IsROrC 𝕜
inst✝ : NormedSpace 𝕜 E
f : ℝ → 𝕜
c : E
⊢ (∫ (x : ℝ) in a..b, f x • c ∂μ) = (∫ (x : ℝ) in a..b, f x ∂μ) • c
Theorem: real_inner_div_norm_mul_norm_eq_neg_one_iff
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← neg_eq_iff_eq_neg, ← neg_div, ← inner_neg_right, ← norm_neg y,
  real_inner_div_norm_mul_norm_eq_one_iff, (@neg_surjective ℝ _).exists]
state_before: 𝕜 : Type ?u.3228331
E : Type ?u.3228334
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ inner x y / (‖x‖ * ‖y‖) = -1 ↔ x ≠ 0 ∧ ∃ r, r < 0 ∧ y = r • x

tactic: refine' Iff.rfl.and (exists_congr fun r => _)
state_before: 𝕜 : Type ?u.3228331
E : Type ?u.3228334
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ (x ≠ 0 ∧ ∃ x_1, 0 < -x_1 ∧ -y = -x_1 • x) ↔ x ≠ 0 ∧ ∃ r, r < 0 ∧ y = r • x

tactic: rw [neg_pos, neg_smul, neg_inj]
state_before: 𝕜 : Type ?u.3228331
E : Type ?u.3228334
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
r : ℝ
⊢ 0 < -r ∧ -y = -r • x ↔ r < 0 ∧ y = r • x
Theorem: tendsto_ceil_right
File: Mathlib/Topology/Algebra/Order/Floor.lean

tactic: rw [← @cast_one α, ← cast_add]
state_before: α : Type u_1
β : Type ?u.17413
γ : Type ?u.17416
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
n : ℤ
⊢ pure (IntCast.intCast (n + 1)) ≤ 𝓝[Ici (↑n + 1)] (↑n + 1)

tactic: exact pure_le_nhdsWithin le_rfl
state_before: α : Type u_1
β : Type ?u.17413
γ : Type ?u.17416
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
n : ℤ
⊢ pure (IntCast.intCast (n + 1)) ≤ 𝓝[Ici ↑(n + 1)] ↑(n + 1)
Theorem: Nat.cond_decide_mod_two
File: Mathlib/Init/Data/Nat/Lemmas.lean

tactic: by_cases h : x % 2 = 1
state_before: x : ℕ
d : Decidable (x % 2 = 1)
⊢ (bif decide (x % 2 = 1) then 1 else 0) = x % 2

tactic: simp! [*]
state_before: case pos
x : ℕ
d : Decidable (x % 2 = 1)
h : x % 2 = 1
⊢ (bif decide (x % 2 = 1) then 1 else 0) = x % 2

tactic: cases mod_two_eq_zero_or_one x <;> simp! [*, Nat.zero_ne_one]
state_before: case neg
x : ℕ
d : Decidable (x % 2 = 1)
h : ¬x % 2 = 1
⊢ (bif decide (x % 2 = 1) then 1 else 0) = x % 2