tasksource/leandojo huggingface dataset:
Theorem: exists_vector_zero
File: Mathlib/Data/Vector3.lean

tactic: rw [← eq_nil v]
state_before: α : Type u_1
m n : ℕ
f : Vector3 α 0 → Prop
x✝ : Exists f
v : Vector3 α 0
fv : f v
⊢ f []

tactic: exact fv
state_before: α : Type u_1
m n : ℕ
f : Vector3 α 0 → Prop
x✝ : Exists f
v : Vector3 α 0
fv : f v
⊢ f v
Theorem: Nat.max_comm
File: Std/Data/Nat/Lemmas.lean

tactic: simp only [Nat.max_def]
state_before: a b : Nat
⊢ max a b = max b a

tactic: by_cases h₁ : a ≤ b <;> by_cases h₂ : b ≤ a <;> simp [h₁, h₂]
state_before: a b : Nat
⊢ (if a ≤ b then b else a) = if b ≤ a then a else b

tactic: exact Nat.le_antisymm h₂ h₁
state_before: case pos
a b : Nat
h₁ : a ≤ b
h₂ : b ≤ a
⊢ b = a

tactic: cases not_or_intro h₁ h₂ <| Nat.le_total ..
state_before: case neg
a b : Nat
h₁ : ¬a ≤ b
h₂ : ¬b ≤ a
⊢ a = b
Theorem: Finsupp.support_smul
File: Mathlib/Data/Finsupp/Basic.lean

tactic: simp only [smul_apply, mem_support_iff, Ne.def]
state_before: α : Type u_3
β : Type ?u.617480
γ : Type ?u.617483
ι : Type ?u.617486
M : Type u_1
M' : Type ?u.617492
N : Type ?u.617495
P : Type ?u.617498
G : Type ?u.617501
H : Type ?u.617504
R : Type u_2
S : Type ?u.617510
inst✝¹ : AddMonoid M
inst✝ : SMulZeroClass R M
b : R
g : α →₀ M
a : α
⊢ a ∈ (b • g).support → a ∈ g.support

tactic: exact mt fun h => h.symm ▸ smul_zero _
state_before: α : Type u_3
β : Type ?u.617480
γ : Type ?u.617483
ι : Type ?u.617486
M : Type u_1
M' : Type ?u.617492
N : Type ?u.617495
P : Type ?u.617498
G : Type ?u.617501
H : Type ?u.617504
R : Type u_2
S : Type ?u.617510
inst✝¹ : AddMonoid M
inst✝ : SMulZeroClass R M
b : R
g : α →₀ M
a : α
⊢ ¬b • ↑g a = 0 → ¬↑g a = 0
Theorem: GeneralizedContinuedFraction.convergents'Aux_stable_of_terminated
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

tactic: induction' n_le_m with m n_le_m IH
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n m : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
n_le_m : n ≤ m
terminated_at_n : Stream'.Seq.TerminatedAt s n
⊢ convergents'Aux s m = convergents'Aux s n

tactic: rfl
state_before: case refl
K : Type u_1
g : GeneralizedContinuedFraction K
n m : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminated_at_n : Stream'.Seq.TerminatedAt s n
⊢ convergents'Aux s n = convergents'Aux s n

tactic: refine' (convergents'Aux_stable_step_of_terminated _).trans IH
state_before: case step
K : Type u_1
g : GeneralizedContinuedFraction K
n m✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminated_at_n : Stream'.Seq.TerminatedAt s n
m : ℕ
n_le_m : Nat.le n m
IH : convergents'Aux s m = convergents'Aux s n
⊢ convergents'Aux s (Nat.succ m) = convergents'Aux s n

tactic: exact s.terminated_stable n_le_m terminated_at_n
state_before: case step
K : Type u_1
g : GeneralizedContinuedFraction K
n m✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminated_at_n : Stream'.Seq.TerminatedAt s n
m : ℕ
n_le_m : Nat.le n m
IH : convergents'Aux s m = convergents'Aux s n
⊢ Stream'.Seq.TerminatedAt s m
Theorem: TopologicalSpace.Opens.coe_iSup
File: Mathlib/Topology/Sets/Opens.lean

tactic: simp [iSup]
state_before: ι✝ : Type ?u.17100
α : Type u_2
β : Type ?u.17106
γ : Type ?u.17109
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
ι : Sort u_1
s : ι → Opens α
⊢ ↑(⨆ (i : ι), s i) = ⋃ (i : ι), ↑(s i)
Theorem: Dfinsupp.filter_add
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → AddZeroClass (β i)
p : ι → Prop
inst✝ : DecidablePred p
f g : Π₀ (i : ι), β i
⊢ filter p (f + g) = filter p f + filter p g

tactic: simp [ite_add_zero]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → AddZeroClass (β i)
p : ι → Prop
inst✝ : DecidablePred p
f g : Π₀ (i : ι), β i
i✝ : ι
⊢ ↑(filter p (f + g)) i✝ = ↑(filter p f + filter p g) i✝
Theorem: HasSum.nonneg_add_neg
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simp_rw [← Int.negSucc_coe] at hneg
state_before: α : Type u_1
β : Type ?u.477720
γ : Type ?u.477723
δ : Type ?u.477726
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f✝ g : β → α
a a₁ a₂ b : α
f : ℤ → α
hnonneg : HasSum (fun n => f ↑n) a
hneg : HasSum (fun n => f (-↑(Nat.succ n))) b
⊢ HasSum f (a + b)

tactic: convert hnonneg.int_rec hneg using 1
state_before: α : Type u_1
β : Type ?u.477720
γ : Type ?u.477723
δ : Type ?u.477726
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f✝ g : β → α
a a₁ a₂ b : α
f : ℤ → α
hnonneg : HasSum (fun n => f ↑n) a
hneg : HasSum (fun n => f (Int.negSucc n)) b
⊢ HasSum f (a + b)

tactic: ext (i | j) <;> rfl
state_before: case h.e'_5
α : Type u_1
β : Type ?u.477720
γ : Type ?u.477723
δ : Type ?u.477726
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f✝ g : β → α
a a₁ a₂ b : α
f : ℤ → α
hnonneg : HasSum (fun n => f ↑n) a
hneg : HasSum (fun n => f (Int.negSucc n)) b
⊢ f = Int.rec (fun n => f ↑n) fun n => f (Int.negSucc n)
Theorem: MeasureTheory.snorm_eq_zero_and_zero_of_ae_le_mul_neg
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp_rw [le_mul_iff_eq_zero_of_nonneg_of_neg_of_nonneg (norm_nonneg _) hc (norm_nonneg _),
  norm_eq_zero, eventually_and] at h
state_before: α : Type u_1
E : Type ?u.5065049
F : Type u_2
G : Type u_3
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
c : ℝ
h : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c * ‖g x‖
hc : c < 0
p : ℝ≥0∞
⊢ snorm f p μ = 0 ∧ snorm g p μ = 0

tactic: change f =ᵐ[μ] 0 ∧ g =ᵐ[μ] 0 at h
state_before: α : Type u_1
E : Type ?u.5065049
F : Type u_2
G : Type u_3
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
c : ℝ
hc : c < 0
p : ℝ≥0∞
h : (∀ᵐ (x : α) ∂μ, f x = 0) ∧ ∀ᵐ (x : α) ∂μ, g x = 0
⊢ snorm f p μ = 0 ∧ snorm g p μ = 0

tactic: simp [snorm_congr_ae h.1, snorm_congr_ae h.2]
state_before: α : Type u_1
E : Type ?u.5065049
F : Type u_2
G : Type u_3
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
g : α → G
c : ℝ
hc : c < 0
p : ℝ≥0∞
h : f =ᵐ[μ] 0 ∧ g =ᵐ[μ] 0
⊢ snorm f p μ = 0 ∧ snorm g p μ = 0
Theorem: Set.Definable.mono
File: Mathlib/ModelTheory/Definability.lean

tactic: rw [definable_iff_empty_definable_with_params] at *
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.8472
B : Set M
s : Set (α → M)
hAs : Definable A L s
hAB : A ⊆ B
⊢ Definable B L s

tactic: exact hAs.map_expansion (L.lhomWithConstantsMap (Set.inclusion hAB))
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.8472
B : Set M
s : Set (α → M)
hAs : Definable ∅ (L[[↑A]]) s
hAB : A ⊆ B
⊢ Definable ∅ (L[[↑B]]) s
Theorem: MeasureTheory.Measure.OuterRegular.smul
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: rcases eq_or_ne x 0 with (rfl | h0)
state_before: α : Type u_1
β : Type ?u.15149
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ μ : Measure α
inst✝ : OuterRegular μ
x : ℝ≥0∞
hx : x ≠ ⊤
⊢ OuterRegular (x • μ)

tactic: rw [zero_smul]
state_before: case inl
α : Type u_1
β : Type ?u.15149
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ μ : Measure α
inst✝ : OuterRegular μ
hx : 0 ≠ ⊤
⊢ OuterRegular (0 • μ)

tactic: exact OuterRegular.zero
state_before: case inl
α : Type u_1
β : Type ?u.15149
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ μ : Measure α
inst✝ : OuterRegular μ
hx : 0 ≠ ⊤
⊢ OuterRegular 0

tactic: refine' ⟨fun A _ r hr => _⟩
state_before: case inr
α : Type u_1
β : Type ?u.15149
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ μ : Measure α
inst✝ : OuterRegular μ
x : ℝ≥0∞
hx : x ≠ ⊤
h0 : x ≠ 0
⊢ OuterRegular (x • μ)

tactic: rw [smul_apply, A.measure_eq_iInf_isOpen, smul_eq_mul] at hr
state_before: case inr
α : Type u_1
β : Type ?u.15149
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ μ : Measure α
inst✝ : OuterRegular μ
x : ℝ≥0∞
hx : x ≠ ⊤
h0 : x ≠ 0
A : Set α
x✝ : MeasurableSet A
r : ℝ≥0∞
hr : r > ↑↑(x • μ) A
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑(x • μ) U < r

tactic: simpa only [ENNReal.mul_iInf_of_ne h0 hx, gt_iff_lt, iInf_lt_iff, exists_prop] using hr
state_before: case inr
α : Type u_1
β : Type ?u.15149
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ μ : Measure α
inst✝ : OuterRegular μ
x : ℝ≥0∞
hx : x ≠ ⊤
h0 : x ≠ 0
A : Set α
x✝ : MeasurableSet A
r : ℝ≥0∞
hr : r > x * ⨅ (U : Set α) (_ : A ⊆ U) (_ : IsOpen U), ↑↑μ U
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑(x • μ) U < r
Theorem: Filter.map_neBot_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [neBot_iff, Ne, map_eq_bot_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.277507
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
F : Filter α
⊢ NeBot (map f F) ↔ NeBot F
Theorem: map_prod
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp only [Finset.prod_eq_multiset_prod, map_multiset_prod, Multiset.map_map]
state_before: ι : Type ?u.92899
β : Type u
α : Type v
γ : Type w
inst✝² : CommMonoid β
inst✝¹ : CommMonoid γ
G : Type u_1
inst✝ : MonoidHomClass G β γ
g : G
f : α → β
s : Finset α
⊢ ↑g (∏ x in s, f x) = ∏ x in s, ↑g (f x)

tactic: rfl
state_before: ι : Type ?u.92899
β : Type u
α : Type v
γ : Type w
inst✝² : CommMonoid β
inst✝¹ : CommMonoid γ
G : Type u_1
inst✝ : MonoidHomClass G β γ
g : G
f : α → β
s : Finset α
⊢ Multiset.prod (Multiset.map ((fun x => ↑g x) ∘ fun x => f x) s.val) =
    Multiset.prod (Multiset.map (fun x => ↑g (f x)) s.val)
Theorem: Summable.mul_of_nonneg
File: Mathlib/Analysis/Normed/Field/InfiniteSum.lean

tactic: simpa only [hg.tsum_mul_left _] using hf.mul_right (∑' x, g x)
state_before: R : Type ?u.14
ι : Type u_1
ι' : Type u_2
inst✝ : NormedRing R
f : ι → ℝ
g : ι' → ℝ
hf : Summable f
hg : Summable g
hf' : 0 ≤ f
hg' : 0 ≤ g
⊢ Summable fun x => ∑' (y : ι'), f (x, y).fst * g (x, y).snd
Theorem: FirstOrder.Language.Term.relabel_id
File: Mathlib/ModelTheory/Syntax.lean

tactic: induction' t with _ _ _ _ ih
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.5062
P : Type ?u.5065
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.5093
t : Term L α
⊢ relabel id t = t

tactic: rfl
state_before: case var
L : Language
L' : Language
M : Type w
N : Type ?u.5062
P : Type ?u.5065
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.5093
_a✝ : α
⊢ relabel id (var _a✝) = var _a✝

tactic: simp [ih]
state_before: case func
L : Language
L' : Language
M : Type w
N : Type ?u.5062
P : Type ?u.5065
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.5093
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih : ∀ (a : Fin l✝), relabel id (_ts✝ a) = _ts✝ a
⊢ relabel id (func _f✝ _ts✝) = func _f✝ _ts✝
Theorem: SimpleGraph.ConnectedComponent.supp_injective
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: refine' ConnectedComponent.ind₂ _
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
⊢ Injective supp

tactic: intro v w
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
⊢ ∀ (v w : V),
    supp (connectedComponentMk G v) = supp (connectedComponentMk G w) →
      connectedComponentMk G v = connectedComponentMk G w

tactic: simp only [ConnectedComponent.supp, Set.ext_iff, ConnectedComponent.eq, Set.mem_setOf_eq]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ supp (connectedComponentMk G v) = supp (connectedComponentMk G w) →
    connectedComponentMk G v = connectedComponentMk G w

tactic: intro h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
⊢ (∀ (x : V), Reachable G x v ↔ Reachable G x w) → Reachable G v w

tactic: rw [reachable_comm, h]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w : V
h : ∀ (x : V), Reachable G x v ↔ Reachable G x w
⊢ Reachable G v w
Theorem: ENNReal.toReal_sum
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [ENNReal.toReal, toNNReal_sum hf, NNReal.coe_sum]
state_before: α : Type u_1
β : Type ?u.203569
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Finset α
f : α → ℝ≥0∞
hf : ∀ (a : α), a ∈ s → f a ≠ ⊤
⊢ ENNReal.toReal (∑ a in s, f a) = ∑ a in s, ENNReal.toReal (f a)

tactic: rfl
state_before: α : Type u_1
β : Type ?u.203569
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Finset α
f : α → ℝ≥0∞
hf : ∀ (a : α), a ∈ s → f a ≠ ⊤
⊢ ∑ a in s, ↑(ENNReal.toNNReal (f a)) = ∑ a in s, ENNReal.toReal (f a)
Theorem: Set.Iic_diff_Iio_same
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [← Iic_diff_right, diff_diff_cancel_left (singleton_subset_iff.2 right_mem_Iic)]
state_before: α : Type u_1
β : Type ?u.45487
inst✝ : PartialOrder α
a b c : α
⊢ Iic a \ Iio a = {a}
Theorem: CategoryTheory.Abelian.Pseudoelement.apply_zero
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: rw [pseudoZero_def, pseudoApply_mk']
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
⊢ pseudoApply f 0 = 0

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
⊢ Quotient.mk (setoid Q) (Over.mk ((Over.mk 0).hom ≫ f)) = 0
Theorem: Metric.emetric_ball_nnreal
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [← Metric.emetric_ball]
state_before: α : Type u
β : Type v
X : Type ?u.164621
ι : Type ?u.164624
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ≥0
⊢ EMetric.ball x ↑ε = ball x ↑ε

tactic: simp
state_before: α : Type u
β : Type v
X : Type ?u.164621
ι : Type ?u.164624
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ≥0
⊢ EMetric.ball x ↑ε = EMetric.ball x (ENNReal.ofReal ↑ε)
Theorem: balancedHull.balanced
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

tactic: intro a ha
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.26762
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
⊢ Balanced 𝕜 (balancedHull 𝕜 s)

tactic: simp_rw [balancedHull, smul_set_iUnion₂, subset_def, mem_iUnion₂]
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.26762
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
⊢ a • balancedHull 𝕜 s ⊆ balancedHull 𝕜 s

tactic: rintro x ⟨r, hr, hx⟩
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.26762
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
⊢ ∀ (x : E), (∃ i j, x ∈ a • i • s) → ∃ i j, x ∈ i • s

tactic: rw [← smul_assoc] at hx
state_before: case intro.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.26762
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
x : E
r : 𝕜
hr : ‖r‖ ≤ 1
hx : x ∈ a • r • s
⊢ ∃ i j, x ∈ i • s

tactic: exact ⟨a • r, (SeminormedRing.norm_mul _ _).trans (mul_le_one ha (norm_nonneg r) hr), hx⟩
state_before: case intro.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.26762
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s✝ s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
x : E
r : 𝕜
hr : ‖r‖ ≤ 1
hx✝ : x ∈ a • r • s
hx : x ∈ (a • r) • s
⊢ ∃ i j, x ∈ i • s
Theorem: MeasureTheory.Measure.pi_univ
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [← pi_univ, pi_pi μ]
state_before: ι : Type u_1
ι' : Type ?u.3159203
α : ι → Type u_2
inst✝² : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝¹ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝ : ∀ (i : ι), SigmaFinite (μ i)
⊢ ↑↑(Measure.pi μ) univ = ∏ i : ι, ↑↑(μ i) univ
Theorem: Matrix.SpecialLinearGroup.row_ne_zero
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: simp [h]
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
A B : SpecialLinearGroup n R
inst✝ : Nontrivial R
g : SpecialLinearGroup n R
i : n
h : ↑g i = 0
⊢ ∀ (j : n), ↑g i j = 0
Theorem: Set.image2_iUnion_left
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [← image_prod, iUnion_prod_const, image_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.247553
ι₂ : Sort ?u.247556
κ : ι → Sort ?u.247561
κ₁ : ι → Sort ?u.247566
κ₂ : ι → Sort ?u.247571
κ' : ι' → Sort ?u.247576
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : ι → Set α
t : Set β
⊢ image2 f (⋃ (i : ι), s i) t = ⋃ (i : ι), image2 f (s i) t
Theorem: IsometryEquiv.diam_preimage
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← image_symm, diam_image]
state_before: ι : Type ?u.1024328
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
h : α ≃ᵢ β
s : Set β
⊢ Metric.diam (↑h ⁻¹' s) = Metric.diam s
Theorem: Complex.equivRealProd_symm_apply
File: Mathlib/Data/Complex/Basic.lean

tactic: ext <;> simp [Complex.equivRealProd, ofReal']
state_before: p : ℝ × ℝ
⊢ ↑equivRealProd.symm p = ↑p.fst + ↑p.snd * I
Theorem: Bitraversable.tsnd_eq_snd_id
File: Mathlib/Control/Bitraversable/Lemmas.lean

tactic: apply bitraverse_eq_bimap_id
state_before: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β✝ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : IsLawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β β' : Type u
f : β → β'
x : t α β
⊢ tsnd (pure ∘ f) x = pure (snd f x)
Theorem: Equiv.Perm.IsCycle.existsUnique_cycle_subtype
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: obtain ⟨s, ⟨hs, rfl⟩, hs'⟩ := hf.existsUnique_cycle
state_before: α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
f : Perm α
hf : IsCycle f
⊢ ∃! s, Cycle.formPerm ↑s (_ : Cycle.Nodup ↑s) = f

tactic: refine' ⟨⟨s, hs⟩, rfl, _⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
s : Cycle α
hs : Cycle.Nodup s
hf : IsCycle (Cycle.formPerm s hs)
hs' : ∀ (y : Cycle α), (fun s_1 => ∃ h, Cycle.formPerm s_1 h = Cycle.formPerm s hs) y → y = s
⊢ ∃! s_1, Cycle.formPerm ↑s_1 (_ : Cycle.Nodup ↑s_1) = Cycle.formPerm s hs

tactic: rintro ⟨t, ht⟩ ht'
state_before: case intro.intro.intro
α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
s : Cycle α
hs : Cycle.Nodup s
hf : IsCycle (Cycle.formPerm s hs)
hs' : ∀ (y : Cycle α), (fun s_1 => ∃ h, Cycle.formPerm s_1 h = Cycle.formPerm s hs) y → y = s
⊢ ∀ (y : { s // Cycle.Nodup s }),
    (fun s_1 => Cycle.formPerm ↑s_1 (_ : Cycle.Nodup ↑s_1) = Cycle.formPerm s hs) y → y = { val := s, property := hs }

tactic: simpa using hs' _ ⟨ht, ht'⟩
state_before: case intro.intro.intro.mk
α : Type u_1
inst✝¹ : Finite α
inst✝ : DecidableEq α
s : Cycle α
hs : Cycle.Nodup s
hf : IsCycle (Cycle.formPerm s hs)
hs' : ∀ (y : Cycle α), (fun s_1 => ∃ h, Cycle.formPerm s_1 h = Cycle.formPerm s hs) y → y = s
t : Cycle α
ht : Cycle.Nodup t
ht' : Cycle.formPerm ↑{ val := t, property := ht } (_ : Cycle.Nodup ↑{ val := t, property := ht }) = Cycle.formPerm s hs
⊢ { val := t, property := ht } = { val := s, property := hs }
Theorem: MeasureTheory.lintegral_strict_mono_of_ae_le_of_frequently_ae_lt
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: contrapose! h
state_before: α : Type u_1
β : Type ?u.984332
γ : Type ?u.984335
δ : Type ?u.984338
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hg : AEMeasurable g
hfi : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h_le : f ≤ᵐ[μ] g
h : ∃ᵐ (x : α) ∂μ, f x ≠ g x
⊢ (∫⁻ (x : α), f x ∂μ) < ∫⁻ (x : α), g x ∂μ

tactic: simp only [not_frequently, Ne.def, Classical.not_not]
state_before: α : Type u_1
β : Type ?u.984332
γ : Type ?u.984335
δ : Type ?u.984338
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hg : AEMeasurable g
hfi : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h_le : f ≤ᵐ[μ] g
h : (∫⁻ (x : α), g x ∂μ) ≤ ∫⁻ (x : α), f x ∂μ
⊢ ¬∃ᵐ (x : α) ∂μ, f x ≠ g x

tactic: exact ae_eq_of_ae_le_of_lintegral_le h_le hfi hg h
state_before: α : Type u_1
β : Type ?u.984332
γ : Type ?u.984335
δ : Type ?u.984338
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
hg : AEMeasurable g
hfi : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
h_le : f ≤ᵐ[μ] g
h : (∫⁻ (x : α), g x ∂μ) ≤ ∫⁻ (x : α), f x ∂μ
⊢ ∀ᵐ (x : α) ∂μ, f x = g x
Theorem: ENNReal.ofReal_prod_of_nonneg
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp_rw [ENNReal.ofReal, ← coe_finset_prod, coe_eq_coe]
state_before: α : Type u_1
β : Type ?u.837756
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Finset α
f : α → ℝ
hf : ∀ (i : α), i ∈ s → 0 ≤ f i
⊢ ENNReal.ofReal (∏ i in s, f i) = ∏ i in s, ENNReal.ofReal (f i)

tactic: exact Real.toNNReal_prod_of_nonneg hf
state_before: α : Type u_1
β : Type ?u.837756
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Finset α
f : α → ℝ
hf : ∀ (i : α), i ∈ s → 0 ≤ f i
⊢ Real.toNNReal (∏ i in s, f i) = ∏ a in s, Real.toNNReal (f a)
Theorem: Int.max_eq_right
File: Std/Data/Int/Lemmas.lean

tactic: simp [Int.max_def, h, Int.not_lt.2 h]
state_before: a b : Int
h : a ≤ b
⊢ max a b = b
Theorem: Rat.toNNRat_inv
File: Mathlib/Data/Rat/NNRat.lean

tactic: obtain hq | hq := le_total q 0
state_before: p q✝ q : ℚ
⊢ toNNRat q⁻¹ = (toNNRat q)⁻¹

tactic: rw [toNNRat_eq_zero.mpr hq, inv_zero, toNNRat_eq_zero.mpr (inv_nonpos.mpr hq)]
state_before: case inl
p q✝ q : ℚ
hq : q ≤ 0
⊢ toNNRat q⁻¹ = (toNNRat q)⁻¹

tactic: nth_rw 1 [← Rat.coe_toNNRat q hq]
state_before: case inr
p q✝ q : ℚ
hq : 0 ≤ q
⊢ toNNRat q⁻¹ = (toNNRat q)⁻¹

tactic: rw [← coe_inv, toNNRat_coe]
state_before: case inr
p q✝ q : ℚ
hq : 0 ≤ q
⊢ toNNRat (↑(toNNRat q))⁻¹ = (toNNRat q)⁻¹
Theorem: Bool.and_eq_true_eq_eq_true_and_eq_true
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: simp
state_before: a b : Bool
⊢ ((a && b) = true) = (a = true ∧ b = true)
Theorem: CategoryTheory.NonPreadditiveAbelian.comp_add
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [add_def, comp_sub, neg_def, comp_sub, comp_zero, add_def, neg_def]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : NonPreadditiveAbelian C
X Y Z : C
f : X ⟶ Y
g h : Y ⟶ Z
⊢ f ≫ (g + h) = f ≫ g + f ≫ h
Theorem: Std.Range.numElems_le_iff
File: Std/Data/Range/Lemmas.lean

tactic: rw [← Nat.lt_succ (n := i), Nat.div_lt_iff_lt_mul hstep, Nat.mul_comm, ← Nat.mul_succ]
state_before: start stop step i : Nat
hstep : 0 < step
⊢ (stop - start + step - 1) / step ≤ i ↔ stop - start + step - 1 < step * i + step

tactic: rw [Nat.add_right_comm, Nat.add_assoc, Nat.sub_add_cancel hstep]
state_before: start stop step i : Nat
hstep : 0 < step
⊢ stop - start + step - 1 < step * i + step ↔ stop - start + step - 1 < step * i + 1 + (step - 1)

tactic: rw [Nat.add_sub_assoc hstep, Nat.add_lt_add_iff_lt_right, Nat.lt_succ,
  Nat.sub_le_iff_le_add']
state_before: start stop step i : Nat
hstep : 0 < step
⊢ stop - start + step - 1 < step * i + 1 + (step - 1) ↔ stop ≤ start + step * i
Theorem: Multiset.antidiagonal_map_snd
File: Mathlib/Data/Multiset/Antidiagonal.lean

tactic: simp [powersetAux']
state_before: α : Type u_1
β : Type ?u.3282
s : Multiset α
l : List α
⊢ map Prod.snd (antidiagonal (Quotient.mk (isSetoid α) l)) = powerset (Quotient.mk (isSetoid α) l)
Theorem: SemiconjBy.units_inv_right
File: Mathlib/Algebra/Group/Semiconj.lean

tactic: rw [Units.inv_mul_cancel_left]
state_before: M : Type u_1
inst✝ : Monoid M
a : M
x y : Mˣ
h : SemiconjBy a ↑x ↑y
⊢ a * ↑x⁻¹ = ↑y⁻¹ * (↑y * a) * ↑x⁻¹

tactic: rw [← h.eq, mul_assoc, Units.mul_inv_cancel_right]
state_before: M : Type u_1
inst✝ : Monoid M
a : M
x y : Mˣ
h : SemiconjBy a ↑x ↑y
⊢ ↑y⁻¹ * (↑y * a) * ↑x⁻¹ = ↑y⁻¹ * a