1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Multiset.fold_bind
File: Mathlib/Data/Multiset/Fold.lean

tactic: induction' s using Multiset.induction_on with a ha ih
state_before: α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
ι : Type u_3
s : Multiset ι
t : ι → Multiset α
b : ι → α
b₀ : α
⊢ fold op (fold op b₀ (map b s)) (s.bind t) = fold op b₀ (map (fun i => fold op (b i) (t i)) s)
state_after: case empty
α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
ι : Type u_3
t : ι → Multiset α
b : ι → α
b₀ : α
⊢ fold op (fold op b₀ (map b 0)) (bind 0 t) = fold op b₀ (map (fun i => fold op (b i) (t i)) 0)

case cons
α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha✝ : Std.Associative op
ι : Type u_3
t : ι → Multiset α
b : ι → α
b₀ : α
a : ι
ha : Multiset ι
ih : fold op (fold op b₀ (map b ha)) (ha.bind t) = fold op b₀ (map (fun i => fold op (b i) (t i)) ha)
⊢ fold op (fold op b₀ (map b (a ::ₘ ha))) ((a ::ₘ ha).bind t) =
    fold op b₀ (map (fun i => fold op (b i) (t i)) (a ::ₘ ha))

tactic: rw [zero_bind, map_zero, map_zero, fold_zero]
state_before: case empty
α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
ι : Type u_3
t : ι → Multiset α
b : ι → α
b₀ : α
⊢ fold op (fold op b₀ (map b 0)) (bind 0 t) = fold op b₀ (map (fun i => fold op (b i) (t i)) 0)
state_after: no goals

tactic: rw [cons_bind, map_cons, map_cons, fold_cons_left, fold_cons_left, fold_add, ih]
state_before: case cons
α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha✝ : Std.Associative op
ι : Type u_3
t : ι → Multiset α
b : ι → α
b₀ : α
a : ι
ha : Multiset ι
ih : fold op (fold op b₀ (map b ha)) (ha.bind t) = fold op b₀ (map (fun i => fold op (b i) (t i)) ha)
⊢ fold op (fold op b₀ (map b (a ::ₘ ha))) ((a ::ₘ ha).bind t) =
    fold op b₀ (map (fun i => fold op (b i) (t i)) (a ::ₘ ha))
state_after: no goals
Theorem: Quiver.Path.nil_ne_cons
File: Mathlib/Combinatorics/Quiver/Path.lean

tactic: injection h
state_before: V : Type u
inst✝ : Quiver V
a b c d : V
p : Path a b
e : b ⟶ a
h : nil = p.cons e
⊢ False
state_after: no goals
Theorem: map_mem_closure₂
File: Mathlib/Topology/Constructions.lean

tactic: simpa only [closure_prod_eq] using mk_mem_prod hx hy
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
f : X → Y → Z
x : X
y : Y
s : Set X
t : Set Y
u : Set Z
hf : Continuous (uncurry f)
hx : x ∈ closure s
hy : y ∈ closure t
h : ∀ a ∈ s, ∀ b ∈ t, f a b ∈ u
⊢ (x, y) ∈ closure (s ×ˢ t)
state_after: no goals
Theorem: Sum.LiftRel.exists_of_isRight_left
File: Mathlib/Data/Sum/Basic.lean

tactic: rcases isRight_iff.mp h₂ with ⟨_, rfl⟩
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
h₁ : LiftRel r s x y
h₂ : x.isRight = true
⊢ ∃ b d, s b d ∧ x = inr b ∧ y = inr d
state_after: case intro
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
w✝ : β
h₁ : LiftRel r s (inr w✝) y
h₂ : (inr w✝).isRight = true
⊢ ∃ b d, s b d ∧ inr w✝ = inr b ∧ y = inr d

tactic: simp only [liftRel_iff, false_and, and_false, exists_false, false_or] at h₁
state_before: case intro
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
w✝ : β
h₁ : LiftRel r s (inr w✝) y
h₂ : (inr w✝).isRight = true
⊢ ∃ b d, s b d ∧ inr w✝ = inr b ∧ y = inr d
state_after: case intro
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
w✝ : β
h₂ : (inr w✝).isRight = true
h₁ : ∃ b d, s b d ∧ inr w✝ = inr b ∧ y = inr d
⊢ ∃ b d, s b d ∧ inr w✝ = inr b ∧ y = inr d

tactic: exact h₁
state_before: case intro
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
w✝ : β
h₂ : (inr w✝).isRight = true
h₁ : ∃ b d, s b d ∧ inr w✝ = inr b ∧ y = inr d
⊢ ∃ b d, s b d ∧ inr w✝ = inr b ∧ y = inr d
state_after: no goals
Theorem: Nat.le_of_lt_add_of_dvd
File: Mathlib/Data/Nat/Defs.lean

tactic: rintro ⟨a, rfl⟩ ⟨b, rfl⟩
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : a < b + n
⊢ n ∣ a → n ∣ b → a ≤ b
state_after: case intro.intro
c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
h : n * a < n * b + n
⊢ n * a ≤ n * b

tactic: rw [← mul_succ] at h
state_before: case intro.intro
c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
h : n * a < n * b + n
⊢ n * a ≤ n * b
state_after: case intro.intro
c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
h : n * a < n * b.succ
⊢ n * a ≤ n * b

tactic: exact Nat.mul_le_mul_left _ (Nat.lt_succ_iff.1 <| Nat.lt_of_mul_lt_mul_left h)
state_before: case intro.intro
c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
h : n * a < n * b.succ
⊢ n * a ≤ n * b
state_after: no goals
Theorem: ENNReal.toReal_le_add'
File: Mathlib/Data/ENNReal/Real.lean

tactic: refine le_trans (toReal_mono' hle ?_) toReal_add_le
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
hle : a ≤ b + c
hb : b = ⊤ → a = ⊤
hc : c = ⊤ → a = ⊤
⊢ a.toReal ≤ b.toReal + c.toReal
state_after: a b c d : ℝ≥0∞
r p q : ℝ≥0
hle : a ≤ b + c
hb : b = ⊤ → a = ⊤
hc : c = ⊤ → a = ⊤
⊢ b + c = ⊤ → a = ⊤

tactic: simpa only [add_eq_top, or_imp] using And.intro hb hc
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
hle : a ≤ b + c
hb : b = ⊤ → a = ⊤
hc : c = ⊤ → a = ⊤
⊢ b + c = ⊤ → a = ⊤
state_after: no goals
Theorem: HasLineDerivWithinAt.congr_mono
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

tactic: simpa using hx
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f f₁ : E → F
f' f₀' f₁' : F
s t : Set E
x v : E
h : HasLineDerivWithinAt 𝕜 f f' s x v
ht : EqOn f₁ f t
hx : f₁ x = f x
h₁ : t ⊆ s
⊢ f₁ (x + 0 • v) = f (x + 0 • v)
state_after: no goals
Theorem: Real.dimH_ball_pi_fin
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

tactic: rw [dimH_ball_pi x hr, Fintype.card_fin]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
C K r✝ : ℝ≥0
f : X → Y
s t : Set X
E : Type u_4
inst✝³ : Fintype ι
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
n : ℕ
x : Fin n → ℝ
r : ℝ
hr : 0 < r
⊢ dimH (Metric.ball x r) = ↑n
state_after: no goals
Theorem: IsUnit.liftRight_inv_mul
File: Mathlib/Algebra/Group/Units/Hom.lean

tactic: intro
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x : M
⊢ ∀ (x : M), ↑⋯.unit = f x
state_after: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x x✝ : M
⊢ ↑⋯.unit = f x✝

tactic: rfl
state_before: F : Type u_1
G : Type u_2
α : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : FunLike F M N
inst✝² : FunLike G N M
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (f x)
x x✝ : M
⊢ ↑⋯.unit = f x✝
state_after: no goals
Theorem: Quaternion.mul_re
File: Mathlib/Algebra/Quaternion.lean

tactic: simp only [one_mul, neg_mul, sub_eq_add_neg, neg_neg]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ a.re * b.re + -1 * a.imI * b.imI + -1 * a.imJ * b.imJ - -1 * -1 * a.imK * b.imK =
    a.re * b.re - a.imI * b.imI - a.imJ * b.imJ - a.imK * b.imK
state_after: no goals
Theorem: ProbabilityTheory.iCondIndepSet_iff
File: Mathlib/Probability/Independence/Conditional.lean

tactic: rw [iCondIndepSet_iff_iCondIndepSets_singleton _ _ _ hs, iCondIndepSets_singleton_iff _ _ _ hs]
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
s : ι → Set Ω
hs : ∀ (i : ι), MeasurableSet (s i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ iCondIndepSet m' hm' s μ ↔
    ∀ (S : Finset ι), μ[(⋂ i ∈ S, s i).indicator fun ω => 1|m'] =ᶠ[ae μ] ∏ i ∈ S, μ[(s i).indicator fun ω => 1|m']
state_after: no goals
Theorem: Real.arcsin_eq_pi_div_two_sub_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: simp [arccos]
state_before: x✝ y x : ℝ
⊢ arcsin x = π / 2 - arccos x
state_after: no goals
Theorem: SimpleGraph.fromEdgeSet_disjoint
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rw [disjoint_comm, disjoint_fromEdgeSet, disjoint_comm]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ Disjoint (fromEdgeSet s) G ↔ Disjoint s G.edgeSet
state_after: no goals
Theorem: Measurable.ennreal_tsum'
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean

tactic: convert Measurable.ennreal_tsum h with x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ Measurable (∑' (i : ι), f i)
state_after: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
x : α
⊢ tsum (fun i => f i) x = ∑' (i : ι), f i x

tactic: exact tsum_apply (Pi.summable.2 fun _ => ENNReal.summable)
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_5
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
x : α
⊢ tsum (fun i => f i) x = ∑' (i : ι), f i x
state_after: no goals
Theorem: SetTheory.PGame.zero_equiv_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_equiv_iff, neg_zero]
state_before: xl xr : Type u
x : PGame
⊢ 0 ≈ -x ↔ 0 ≈ x
state_after: no goals
Theorem: Set.Icc.addNSMul_zero
File: Mathlib/Topology/UnitInterval.lean

tactic: rw [addNSMul, zero_smul, add_zero, projIcc_left]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
⊢ ↑(addNSMul h δ 0) = a
state_after: no goals
Theorem: MeasureTheory.lintegral_withDensity_le_lintegral_mul
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

tactic: rw [← iSup_lintegral_measurable_le_eq_lintegral, ← iSup_lintegral_measurable_le_eq_lintegral]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g : α → ℝ≥0∞
⊢ ∫⁻ (a : α), g a ∂μ.withDensity f ≤ ∫⁻ (a : α), (f * g) a ∂μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g : α → ℝ≥0∞
⊢ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ g), ∫⁻ (a : α), g_1 a ∂μ.withDensity f ≤
    ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ

tactic: refine iSup₂_le fun i i_meas => iSup_le fun hi => ?_
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g : α → ℝ≥0∞
⊢ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ g), ∫⁻ (a : α), g_1 a ∂μ.withDensity f ≤
    ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ

tactic: have A : f * i ≤ f * g := fun x => mul_le_mul_left' (hi x) _
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
A : f * i ≤ f * g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ

tactic: refine le_iSup₂_of_le (f * i) (f_meas.mul i_meas) ?_
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
A : f * i ≤ f * g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ g_1, ⨆ (_ : Measurable g_1), ⨆ (_ : g_1 ≤ f * g), ∫⁻ (a : α), g_1 a ∂μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
A : f * i ≤ f * g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ (_ : f * i ≤ f * g), ∫⁻ (a : α), (f * i) a ∂μ

tactic: exact le_iSup_of_le A (le_of_eq (lintegral_withDensity_eq_lintegral_mul _ f_meas i_meas))
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ g
A : f * i ≤ f * g
⊢ ∫⁻ (a : α), i a ∂μ.withDensity f ≤ ⨆ (_ : f * i ≤ f * g), ∫⁻ (a : α), (f * i) a ∂μ
state_after: no goals
Theorem: Int.ceil_add_ceil_le
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← le_sub_iff_add_le, ceil_le, Int.cast_sub, Int.cast_add, Int.cast_one, le_sub_comm]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ⌈a⌉ + ⌈b⌉ ≤ ⌈a + b⌉ + 1
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌈b⌉ ≤ ↑⌈a + b⌉ + 1 - a

tactic: refine (ceil_lt_add_one _).le.trans ?_
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌈b⌉ ≤ ↑⌈a + b⌉ + 1 - a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ b + 1 ≤ ↑⌈a + b⌉ + 1 - a

tactic: rw [le_sub_iff_add_le', ← add_assoc, add_le_add_iff_right]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ b + 1 ≤ ↑⌈a + b⌉ + 1 - a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ a + b ≤ ↑⌈a + b⌉

tactic: exact le_ceil _
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ a + b ≤ ↑⌈a + b⌉
state_after: no goals
Theorem: EuclideanGeometry.oangle_ne_zero_and_ne_pi_iff_affineIndependent
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

tactic: rw [oangle, o.oangle_ne_zero_and_ne_pi_iff_linearIndependent,
  affineIndependent_iff_linearIndependent_vsub ℝ _ (1 : Fin 3), ←
  linearIndependent_equiv (finSuccAboveEquiv (1 : Fin 3)).toEquiv]
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
⊢ ∡ p₁ p₂ p₃ ≠ 0 ∧ ∡ p₁ p₂ p₃ ≠ ↑π ↔ AffineIndependent ℝ ![p₁, p₂, p₃]
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
⊢ LinearIndependent ℝ ![p₁ -ᵥ p₂, p₃ -ᵥ p₂] ↔
    LinearIndependent ℝ ((fun i => ![p₁, p₂, p₃] ↑i -ᵥ ![p₁, p₂, p₃] 1) ∘ ⇑(finSuccAboveEquiv 1).toEquiv)

tactic: convert Iff.rfl
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
⊢ LinearIndependent ℝ ![p₁ -ᵥ p₂, p₃ -ᵥ p₂] ↔
    LinearIndependent ℝ ((fun i => ![p₁, p₂, p₃] ↑i -ᵥ ![p₁, p₂, p₃] 1) ∘ ⇑(finSuccAboveEquiv 1).toEquiv)
state_after: case h.e'_2.h.e'_4
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
⊢ (fun i => ![p₁, p₂, p₃] ↑i -ᵥ ![p₁, p₂, p₃] 1) ∘ ⇑(finSuccAboveEquiv 1).toEquiv = ![p₁ -ᵥ p₂, p₃ -ᵥ p₂]

tactic: ext i
state_before: case h.e'_2.h.e'_4
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
⊢ (fun i => ![p₁, p₂, p₃] ↑i -ᵥ ![p₁, p₂, p₃] 1) ∘ ⇑(finSuccAboveEquiv 1).toEquiv = ![p₁ -ᵥ p₂, p₃ -ᵥ p₂]
state_after: case h.e'_2.h.e'_4.h
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
i : Fin 2
⊢ ((fun i => ![p₁, p₂, p₃] ↑i -ᵥ ![p₁, p₂, p₃] 1) ∘ ⇑(finSuccAboveEquiv 1).toEquiv) i = ![p₁ -ᵥ p₂, p₃ -ᵥ p₂] i

tactic: fin_cases i <;> rfl
state_before: case h.e'_2.h.e'_4.h
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
i : Fin 2
⊢ ((fun i => ![p₁, p₂, p₃] ↑i -ᵥ ![p₁, p₂, p₃] 1) ∘ ⇑(finSuccAboveEquiv 1).toEquiv) i = ![p₁ -ᵥ p₂, p₃ -ᵥ p₂] i
state_after: no goals
Theorem: Nat.repr_length
File: Mathlib/Data/Nat/Digits.lean

tactic: cases n with
  (intro e0 he; simp only [Nat.repr, Nat.toDigits, String.length, List.asString])
| zero => assumption
| succ n =>
  if hterm : n.succ / 10 = 0 then
    simp only [hterm, Nat.toDigitsCore]; assumption
  else
    exact toDigitsCore_length 10 (by decide) (Nat.succ n + 1) (Nat.succ n) e he e0
state_before: n✝ n e : ℕ
⊢ 0 < e → n < 10 ^ e → n.repr.length ≤ e
state_after: no goals

tactic: intro e0 he
state_before: case succ
n✝ e n : ℕ
⊢ 0 < e → n + 1 < 10 ^ e → (n + 1).repr.length ≤ e
state_after: case succ
n✝ e n : ℕ
e0 : 0 < e
he : n + 1 < 10 ^ e
⊢ (n + 1).repr.length ≤ e

tactic: simp only [Nat.repr, Nat.toDigits, String.length, List.asString]
state_before: case succ
n✝ e n : ℕ
e0 : 0 < e
he : n + 1 < 10 ^ e
⊢ (n + 1).repr.length ≤ e
state_after: case succ
n✝ e n : ℕ
e0 : 0 < e
he : n + 1 < 10 ^ e
⊢ (toDigitsCore 10 (n + 1 + 1) (n + 1) []).length ≤ e

tactic: assumption
state_before: case zero
n e : ℕ
e0 : 0 < e
he : 0 < 10 ^ e
⊢ (toDigitsCore 10 (0 + 1) 0 []).length ≤ e
state_after: no goals

tactic: if hterm : n.succ / 10 = 0 then
  simp only [hterm, Nat.toDigitsCore]; assumption
else
  exact toDigitsCore_length 10 (by decide) (Nat.succ n + 1) (Nat.succ n) e he e0
state_before: case succ
n✝ e n : ℕ
e0 : 0 < e
he : n + 1 < 10 ^ e
⊢ (toDigitsCore 10 (n + 1 + 1) (n + 1) []).length ≤ e
state_after: no goals

tactic: simp only [hterm, Nat.toDigitsCore]
state_before: n✝ e n : ℕ
e0 : 0 < e
he : n + 1 < 10 ^ e
hterm : n.succ / 10 = 0
⊢ (toDigitsCore 10 (n + 1 + 1) (n + 1) []).length ≤ e
state_after: n✝ e n : ℕ
e0 : 0 < e
he : n + 1 < 10 ^ e
hterm : n.succ / 10 = 0
⊢ (if True then [((n + 1) % 10).digitChar]
      else
        if True then [(0 % 10).digitChar, ((n + 1) % 10).digitChar]
        else toDigitsCore 10 n (0 / 10) [(0 % 10).digitChar, ((n + 1) % 10).digitChar]).length ≤
    e

tactic: assumption
state_before: n✝ e n : ℕ
e0 : 0 < e
he : n + 1 < 10 ^ e
hterm : n.succ / 10 = 0
⊢ (if True then [((n + 1) % 10).digitChar]
      else
        if True then [(0 % 10).digitChar, ((n + 1) % 10).digitChar]
        else toDigitsCore 10 n (0 / 10) [(0 % 10).digitChar, ((n + 1) % 10).digitChar]).length ≤
    e
state_after: no goals

tactic: exact toDigitsCore_length 10 (by decide) (Nat.succ n + 1) (Nat.succ n) e he e0
state_before: n✝ e n : ℕ
e0 : 0 < e
he : n + 1 < 10 ^ e
hterm : ¬n.succ / 10 = 0
⊢ (toDigitsCore 10 (n + 1 + 1) (n + 1) []).length ≤ e
state_after: no goals

tactic: decide
state_before: n✝ e n : ℕ
e0 : 0 < e
he : n + 1 < 10 ^ e
hterm : ¬n.succ / 10 = 0
⊢ 2 ≤ 10
state_after: no goals
Theorem: Int.csSup_empty
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

tactic: simp
state_before: ⊢ ¬(∅.Nonempty ∧ BddAbove ∅)
state_after: no goals
Theorem: Finset.filter_product_right
File: Mathlib/Data/Finset/Prod.lean

tactic: simpa using filter_product (fun _ : α => true) q
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
q : β → Prop
inst✝ : DecidablePred q
⊢ filter (fun x => q x.2) (s ×ˢ t) = s ×ˢ filter q t
state_after: no goals
Theorem: InnerProductGeometry.norm_sub_sq_eq_norm_sq_add_norm_sq_iff_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [norm_sub_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ ‖x - y‖ * ‖x - y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ angle x y = π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ ⟪x, y⟫_ℝ = 0 ↔ angle x y = π / 2

tactic: exact inner_eq_zero_iff_angle_eq_pi_div_two x y
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ ⟪x, y⟫_ℝ = 0 ↔ angle x y = π / 2
state_after: no goals
Theorem: dual_solid
File: Mathlib/Analysis/Normed/Order/Lattice.lean

tactic: apply solid
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ ‖a‖ ≤ ‖b‖
state_after: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ |a| ≤ |b|

tactic: rw [abs]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ |a| ≤ |b|
state_after: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ a ⊔ -a ≤ |b|

tactic: nth_rw 1 [← neg_neg a]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ a ⊔ -a ≤ |b|
state_after: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ - -a ⊔ -a ≤ |b|

tactic: rw [← neg_inf]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ - -a ⊔ -a ≤ |b|
state_after: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ -(-a ⊓ a) ≤ |b|

tactic: rw [abs]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ -(-a ⊓ a) ≤ |b|
state_after: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ -(-a ⊓ a) ≤ b ⊔ -b

tactic: nth_rw 1 [← neg_neg b]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ -(-a ⊓ a) ≤ b ⊔ -b
state_after: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ -(-a ⊓ a) ≤ - -b ⊔ -b

tactic: rwa [← neg_inf, neg_le_neg_iff, inf_comm _ b, inf_comm _ a]
state_before: case a
α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
a b : α
h : b ⊓ -b ≤ a ⊓ -a
⊢ -(-a ⊓ a) ≤ - -b ⊔ -b
state_after: no goals
Theorem: Polynomial.Chebyshev.U_two
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: have := U_add_two R 0
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ U R 2 = 4 * X ^ 2 - 1
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
this : U R (0 + 2) = 2 * X * U R (0 + 1) - U R 0
⊢ U R 2 = 4 * X ^ 2 - 1

tactic: simp only [zero_add, U_one, U_zero] at this
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
this : U R (0 + 2) = 2 * X * U R (0 + 1) - U R 0
⊢ U R 2 = 4 * X ^ 2 - 1
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
this : U R 2 = 2 * X * (2 * X) - 1
⊢ U R 2 = 4 * X ^ 2 - 1

tactic: linear_combination this
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
this : U R 2 = 2 * X * (2 * X) - 1
⊢ U R 2 = 4 * X ^ 2 - 1
state_after: no goals
Theorem: Bool.bool_iff_false
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: cases b <;> decide
state_before: b : Bool
⊢ ¬b = true ↔ b = false
state_after: no goals