1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SimpleGraph.edgeFinset_sup_edge
File: Mathlib/Combinatorics/SimpleGraph/Operations.lean

tactic: simp_all
state_before: V : Type u_1
inst✝³ : DecidableEq V
G : SimpleGraph V
s t : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype ↑(G ⊔ edge s t).edgeSet
hn : ¬G.Adj s t
h : s ≠ t
⊢ s(s, t) ∉ G.edgeFinset
state_after: no goals

tactic: letI := Classical.decEq V
state_before: V : Type u_1
inst✝³ : DecidableEq V
G : SimpleGraph V
s t : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype ↑(G ⊔ edge s t).edgeSet
hn : ¬G.Adj s t
h : s ≠ t
⊢ (G ⊔ edge s t).edgeFinset = cons s(s, t) G.edgeFinset ⋯
state_after: V : Type u_1
inst✝³ : DecidableEq V
G : SimpleGraph V
s t : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype ↑(G ⊔ edge s t).edgeSet
hn : ¬G.Adj s t
h : s ≠ t
this : DecidableEq V := Classical.decEq V
⊢ (G ⊔ edge s t).edgeFinset = cons s(s, t) G.edgeFinset ⋯

tactic: rw [edgeFinset_sup, cons_eq_insert, insert_eq, union_comm]
state_before: V : Type u_1
inst✝³ : DecidableEq V
G : SimpleGraph V
s t : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype ↑(G ⊔ edge s t).edgeSet
hn : ¬G.Adj s t
h : s ≠ t
this : DecidableEq V := Classical.decEq V
⊢ (G ⊔ edge s t).edgeFinset = cons s(s, t) G.edgeFinset ⋯
state_after: V : Type u_1
inst✝³ : DecidableEq V
G : SimpleGraph V
s t : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype ↑(G ⊔ edge s t).edgeSet
hn : ¬G.Adj s t
h : s ≠ t
this : DecidableEq V := Classical.decEq V
⊢ (edge s t).edgeFinset ∪ G.edgeFinset = {s(s, t)} ∪ G.edgeFinset

tactic: simp_rw [edgeFinset, edge_edgeSet_of_ne h]
state_before: V : Type u_1
inst✝³ : DecidableEq V
G : SimpleGraph V
s t : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype ↑(G ⊔ edge s t).edgeSet
hn : ¬G.Adj s t
h : s ≠ t
this : DecidableEq V := Classical.decEq V
⊢ (edge s t).edgeFinset ∪ G.edgeFinset = {s(s, t)} ∪ G.edgeFinset
state_after: V : Type u_1
inst✝³ : DecidableEq V
G : SimpleGraph V
s t : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype ↑(G ⊔ edge s t).edgeSet
hn : ¬G.Adj s t
h : s ≠ t
this : DecidableEq V := Classical.decEq V
⊢ {s(s, t)}.toFinset ∪ G.edgeSet.toFinset = {s(s, t)} ∪ G.edgeSet.toFinset

tactic: rfl
state_before: V : Type u_1
inst✝³ : DecidableEq V
G : SimpleGraph V
s t : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Fintype ↑(G ⊔ edge s t).edgeSet
hn : ¬G.Adj s t
h : s ≠ t
this : DecidableEq V := Classical.decEq V
⊢ {s(s, t)}.toFinset ∪ G.edgeSet.toFinset = {s(s, t)} ∪ G.edgeSet.toFinset
state_after: no goals
Theorem: WithBot.preimage_coe_Ioc
File: Mathlib/Order/Interval/Set/WithBotTop.lean

tactic: simp [← Ioi_inter_Iic]
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some ⁻¹' Ioc ↑a ↑b = Ioc a b
state_after: no goals
Theorem: convexOn_dist
File: Mathlib/Analysis/Convex/Normed.lean

tactic: simpa [dist_eq_norm, preimage_preimage] using
  (convexOn_norm (hs.translate (-z))).comp_affineMap (AffineMap.id ℝ E - AffineMap.const ℝ E z)
state_before: ι : Type u_1
E : Type u_2
P : Type u_3
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
s t : Set E
z : E
hs : Convex ℝ s
⊢ ConvexOn ℝ s fun z' => dist z' z
state_after: no goals
Theorem: Finset.compls_univ
File: Mathlib/Data/Finset/Sups.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : BooleanAlgebra α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
inst✝ : Fintype α
⊢ univᶜˢ = univ
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : BooleanAlgebra α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
inst✝ : Fintype α
a✝ : α
⊢ a✝ ∈ univᶜˢ ↔ a✝ ∈ univ

tactic: simp
state_before: case a
F : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : BooleanAlgebra α
s s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
inst✝ : Fintype α
a✝ : α
⊢ a✝ ∈ univᶜˢ ↔ a✝ ∈ univ
state_after: no goals
Theorem: Set.Ioc_eq_empty_iff
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [← not_nonempty_iff_eq_empty, not_iff_not, nonempty_Ioc]
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Ioc a b = ∅ ↔ ¬a < b
state_after: no goals
Theorem: MeasureTheory.Memℒp.variance_eq
File: Mathlib/Probability/Variance.lean

tactic: rw [variance, evariance_eq_lintegral_ofReal, ← ofReal_integral_eq_lintegral_ofReal,
  ENNReal.toReal_ofReal (by positivity)]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ variance X μ = ∫ (x : Ω), ((X - fun x => ∫ (x : Ω), X x ∂μ) ^ 2) x ∂μ
state_after: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ ∫ (x : Ω), (X x - ∫ (x : Ω), X x ∂μ) ^ 2 ∂μ = ∫ (x : Ω), ((X - fun x => ∫ (x : Ω), X x ∂μ) ^ 2) x ∂μ

case hfi
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ Integrable (fun ω => (X ω - ∫ (x : Ω), X x ∂μ) ^ 2) μ

case f_nn
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ 0 ≤ᶠ[ae μ] fun ω => (X ω - ∫ (x : Ω), X x ∂μ) ^ 2

tactic: positivity
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ 0 ≤ ∫ (x : Ω), (X x - ∫ (x : Ω), X x ∂μ) ^ 2 ∂μ
state_after: no goals

tactic: rfl
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ ∫ (x : Ω), (X x - ∫ (x : Ω), X x ∂μ) ^ 2 ∂μ = ∫ (x : Ω), ((X - fun x => ∫ (x : Ω), X x ∂μ) ^ 2) x ∂μ
state_after: no goals

tactic: convert (hX.sub <| memℒp_const (μ [X])).integrable_norm_rpow two_ne_zero ENNReal.two_ne_top
  with ω
state_before: case hfi
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ Integrable (fun ω => (X ω - ∫ (x : Ω), X x ∂μ) ^ 2) μ
state_after: case h.e'_5.h
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
ω : Ω
⊢ (X ω - ∫ (x : Ω), X x ∂μ) ^ 2 = ‖(X - fun x => ∫ (x : Ω), X x ∂μ) ω‖ ^ ENNReal.toReal 2

tactic: simp only [Pi.sub_apply, Real.norm_eq_abs, ENNReal.toReal_ofNat, ENNReal.one_toReal,
  Real.rpow_two, sq_abs, abs_pow]
state_before: case h.e'_5.h
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
ω : Ω
⊢ (X ω - ∫ (x : Ω), X x ∂μ) ^ 2 = ‖(X - fun x => ∫ (x : Ω), X x ∂μ) ω‖ ^ ENNReal.toReal 2
state_after: no goals

tactic: exact ae_of_all _ fun ω => pow_two_nonneg _
state_before: case f_nn
Ω : Type u_1
m : MeasurableSpace Ω
X : Ω → ℝ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ 0 ≤ᶠ[ae μ] fun ω => (X ω - ∫ (x : Ω), X x ∂μ) ^ 2
state_after: no goals
Theorem: Order.not_isSuccLimit_iff'
File: Mathlib/Order/SuccPred/Limit.lean

tactic: simp_rw [isSuccLimit_iff_succ_ne, not_forall, not_ne_iff]
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
C : α → Sort u_2
inst✝ : NoMaxOrder α
⊢ ¬IsSuccLimit a ↔ a ∈ range succ
state_after: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
C : α → Sort u_2
inst✝ : NoMaxOrder α
⊢ (∃ x, succ x = a) ↔ a ∈ range succ

tactic: rfl
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
C : α → Sort u_2
inst✝ : NoMaxOrder α
⊢ (∃ x, succ x = a) ↔ a ∈ range succ
state_after: no goals
Theorem: Real.pi_upper_bound_start
File: Mathlib/Data/Real/Pi/Bounds.lean

tactic: refine lt_of_lt_of_le (pi_lt_sqrtTwoAddSeries n) ?_
state_before: n : ℕ
a : ℝ
h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n
h₂ : 1 / 4 ^ n ≤ a
⊢ π < a
state_after: n : ℕ
a : ℝ
h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n
h₂ : 1 / 4 ^ n ≤ a
⊢ 2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) + 1 / 4 ^ n ≤ a

tactic: rw [← le_sub_iff_add_le, ← le_div_iff', sqrt_le_left, sub_le_comm]
state_before: n : ℕ
a : ℝ
h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n
h₂ : 1 / 4 ^ n ≤ a
⊢ 2 ^ (n + 1) * √(2 - sqrtTwoAddSeries 0 n) + 1 / 4 ^ n ≤ a
state_after: n : ℕ
a : ℝ
h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n
h₂ : 1 / 4 ^ n ≤ a
⊢ 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ sqrtTwoAddSeries 0 n

n : ℕ
a : ℝ
h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n
h₂ : 1 / 4 ^ n ≤ a
⊢ 0 ≤ (a - 1 / 4 ^ n) / 2 ^ (n + 1)

n : ℕ
a : ℝ
h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n
h₂ : 1 / 4 ^ n ≤ a
⊢ 0 < 2 ^ (n + 1)

tactic: rwa [Nat.cast_zero, zero_div] at h
state_before: n : ℕ
a : ℝ
h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n
h₂ : 1 / 4 ^ n ≤ a
⊢ 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ sqrtTwoAddSeries 0 n
state_after: no goals

tactic: exact div_nonneg (sub_nonneg.2 h₂) (pow_nonneg (le_of_lt zero_lt_two) _)
state_before: n : ℕ
a : ℝ
h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n
h₂ : 1 / 4 ^ n ≤ a
⊢ 0 ≤ (a - 1 / 4 ^ n) / 2 ^ (n + 1)
state_after: no goals

tactic: exact pow_pos zero_lt_two _
state_before: n : ℕ
a : ℝ
h : 2 - ((a - 1 / 4 ^ n) / 2 ^ (n + 1)) ^ 2 ≤ (↑0 / ↑1).sqrtTwoAddSeries n
h₂ : 1 / 4 ^ n ≤ a
⊢ 0 < 2 ^ (n + 1)
state_after: no goals
Theorem: Monoid.PushoutI.NormalWord.prod_injective
File: Mathlib/GroupTheory/PushoutI.lean

tactic: letI := Classical.decEq ι
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
⊢ Injective prod
state_after: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
this : DecidableEq ι := Classical.decEq ι
⊢ Injective prod

tactic: letI := fun i => Classical.decEq (G i)
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
this : DecidableEq ι := Classical.decEq ι
⊢ Injective prod
state_after: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
this✝ : DecidableEq ι := Classical.decEq ι
this : (i : ι) → DecidableEq (G i) := fun i => Classical.decEq (G i)
⊢ Injective prod

tactic: classical exact equiv.symm.injective
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
this✝ : DecidableEq ι := Classical.decEq ι
this : (i : ι) → DecidableEq (G i) := fun i => Classical.decEq (G i)
⊢ Injective prod
state_after: no goals

tactic: exact equiv.symm.injective
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
this✝ : DecidableEq ι := Classical.decEq ι
this : (i : ι) → DecidableEq (G i) := fun i => Classical.decEq (G i)
⊢ Injective prod
state_after: no goals
Theorem: Profinite.NobelingProof.Products.evalFacProps
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: have : l.eval (π C J) ∘ Homeomorph.setCongr (proj_eq_of_subset C J K hJK) =
    l.eval (π (π C K) J) := by
  ext; simp [Homeomorph.setCongr, Products.eval_eq]
state_before: I : Type u
inst✝³ : LinearOrder I
inst✝² : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
J K : I → Prop
h : ∀ a ∈ ↑l, J a
inst✝¹ : (j : I) → Decidable (J j)
inst✝ : (j : I) → Decidable (K j)
hJK : ∀ (i : I), J i → K i
⊢ ⇑(eval (π C J) l) ∘ ProjRestricts C hJK = ⇑(eval (π C K) l)
state_after: I : Type u
inst✝³ : LinearOrder I
inst✝² : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
J K : I → Prop
h : ∀ a ∈ ↑l, J a
inst✝¹ : (j : I) → Decidable (J j)
inst✝ : (j : I) → Decidable (K j)
hJK : ∀ (i : I), J i → K i
this : ⇑(eval (π C J) l) ∘ ⇑(Homeomorph.setCongr ⋯) = ⇑(eval (π (π C K) J) l)
⊢ ⇑(eval (π C J) l) ∘ ProjRestricts C hJK = ⇑(eval (π C K) l)

tactic: rw [ProjRestricts, ← Function.comp.assoc, this, ← evalFacProp (π C K) J h]
state_before: I : Type u
inst✝³ : LinearOrder I
inst✝² : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
J K : I → Prop
h : ∀ a ∈ ↑l, J a
inst✝¹ : (j : I) → Decidable (J j)
inst✝ : (j : I) → Decidable (K j)
hJK : ∀ (i : I), J i → K i
this : ⇑(eval (π C J) l) ∘ ⇑(Homeomorph.setCongr ⋯) = ⇑(eval (π (π C K) J) l)
⊢ ⇑(eval (π C J) l) ∘ ProjRestricts C hJK = ⇑(eval (π C K) l)
state_after: no goals

tactic: ext
state_before: I : Type u
inst✝³ : LinearOrder I
inst✝² : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
J K : I → Prop
h : ∀ a ∈ ↑l, J a
inst✝¹ : (j : I) → Decidable (J j)
inst✝ : (j : I) → Decidable (K j)
hJK : ∀ (i : I), J i → K i
⊢ ⇑(eval (π C J) l) ∘ ⇑(Homeomorph.setCongr ⋯) = ⇑(eval (π (π C K) J) l)
state_after: case h
I : Type u
inst✝³ : LinearOrder I
inst✝² : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
J K : I → Prop
h : ∀ a ∈ ↑l, J a
inst✝¹ : (j : I) → Decidable (J j)
inst✝ : (j : I) → Decidable (K j)
hJK : ∀ (i : I), J i → K i
x✝ : ↑(π (π C K) J)
⊢ (⇑(eval (π C J) l) ∘ ⇑(Homeomorph.setCongr ⋯)) x✝ = (eval (π (π C K) J) l) x✝

tactic: simp [Homeomorph.setCongr, Products.eval_eq]
state_before: case h
I : Type u
inst✝³ : LinearOrder I
inst✝² : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
l : Products I
J K : I → Prop
h : ∀ a ∈ ↑l, J a
inst✝¹ : (j : I) → Decidable (J j)
inst✝ : (j : I) → Decidable (K j)
hJK : ∀ (i : I), J i → K i
x✝ : ↑(π (π C K) J)
⊢ (⇑(eval (π C J) l) ∘ ⇑(Homeomorph.setCongr ⋯)) x✝ = (eval (π (π C K) J) l) x✝
state_after: no goals
Theorem: SetTheory.PGame.quot_eq_of_mk'_quot_eq
File: Mathlib/SetTheory/Game/Basic.lean

tactic: exact Quot.sound (equiv_of_mk_equiv L R (fun _ => Game.PGame.equiv_iff_game_eq.2 (hl _))
                                        (fun _ => Game.PGame.equiv_iff_game_eq.2 (hr _)))
state_before: x y : PGame
L : x.LeftMoves ≃ y.LeftMoves
R : x.RightMoves ≃ y.RightMoves
hl : ∀ (i : x.LeftMoves), ⟦x.moveLeft i⟧ = ⟦y.moveLeft (L i)⟧
hr : ∀ (j : x.RightMoves), ⟦x.moveRight j⟧ = ⟦y.moveRight (R j)⟧
⊢ ⟦x⟧ = ⟦y⟧
state_after: no goals
Theorem: CategoryTheory.Functor.isRightDerivedFunctor_iff_of_iso
File: Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean

tactic: simp only [isRightDerivedFunctor_iff_isLeftKanExtension]
state_before: C : Type u_1
C' : Type ?u.14411
D : Type u_6
D' : Type ?u.14417
H : Type u_3
H' : Type ?u.14423
inst✝⁶ : Category.{u_4, u_1} C
inst✝⁵ : Category.{?u.14431, ?u.14411} C'
inst✝⁴ : Category.{u_5, u_6} D
inst✝³ : Category.{?u.14439, ?u.14417} D'
inst✝² : Category.{u_2, u_3} H
inst✝¹ : Category.{?u.14447, ?u.14423} H'
RF RF' RF'' : D ⥤ H
F F' F'' : C ⥤ H
e✝ : F ≅ F'
L : C ⥤ D
α : F ⟶ L ⋙ RF
α'✝ : F' ⟶ L ⋙ RF'
α'' : F'' ⟶ L ⋙ RF''
α'₂ : F ⟶ L ⋙ RF'
W✝ : MorphismProperty C
α' : F ⟶ L ⋙ RF'
W : MorphismProperty C
inst✝ : L.IsLocalization W
e : RF ≅ RF'
comm : α ≫ whiskerLeft L e.hom = α'
⊢ RF.IsRightDerivedFunctor α W ↔ RF'.IsRightDerivedFunctor α' W
state_after: C : Type u_1
C' : Type ?u.14411
D : Type u_6
D' : Type ?u.14417
H : Type u_3
H' : Type ?u.14423
inst✝⁶ : Category.{u_4, u_1} C
inst✝⁵ : Category.{?u.14431, ?u.14411} C'
inst✝⁴ : Category.{u_5, u_6} D
inst✝³ : Category.{?u.14439, ?u.14417} D'
inst✝² : Category.{u_2, u_3} H
inst✝¹ : Category.{?u.14447, ?u.14423} H'
RF RF' RF'' : D ⥤ H
F F' F'' : C ⥤ H
e✝ : F ≅ F'
L : C ⥤ D
α : F ⟶ L ⋙ RF
α'✝ : F' ⟶ L ⋙ RF'
α'' : F'' ⟶ L ⋙ RF''
α'₂ : F ⟶ L ⋙ RF'
W✝ : MorphismProperty C
α' : F ⟶ L ⋙ RF'
W : MorphismProperty C
inst✝ : L.IsLocalization W
e : RF ≅ RF'
comm : α ≫ whiskerLeft L e.hom = α'
⊢ RF.IsLeftKanExtension α ↔ RF'.IsLeftKanExtension α'

tactic: exact isLeftKanExtension_iff_of_iso e _ _ comm
state_before: C : Type u_1
C' : Type ?u.14411
D : Type u_6
D' : Type ?u.14417
H : Type u_3
H' : Type ?u.14423
inst✝⁶ : Category.{u_4, u_1} C
inst✝⁵ : Category.{?u.14431, ?u.14411} C'
inst✝⁴ : Category.{u_5, u_6} D
inst✝³ : Category.{?u.14439, ?u.14417} D'
inst✝² : Category.{u_2, u_3} H
inst✝¹ : Category.{?u.14447, ?u.14423} H'
RF RF' RF'' : D ⥤ H
F F' F'' : C ⥤ H
e✝ : F ≅ F'
L : C ⥤ D
α : F ⟶ L ⋙ RF
α'✝ : F' ⟶ L ⋙ RF'
α'' : F'' ⟶ L ⋙ RF''
α'₂ : F ⟶ L ⋙ RF'
W✝ : MorphismProperty C
α' : F ⟶ L ⋙ RF'
W : MorphismProperty C
inst✝ : L.IsLocalization W
e : RF ≅ RF'
comm : α ≫ whiskerLeft L e.hom = α'
⊢ RF.IsLeftKanExtension α ↔ RF'.IsLeftKanExtension α'
state_after: no goals
Theorem: le_sdiff
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [← h.2.sdiff_eq_left]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x ≤ y ∧ Disjoint x z
⊢ x ≤ y \ z
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x ≤ y ∧ Disjoint x z
⊢ x \ z ≤ y \ z

tactic: exact sdiff_le_sdiff_right h.1
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
h : x ≤ y ∧ Disjoint x z
⊢ x \ z ≤ y \ z
state_after: no goals
Theorem: Complex.abs_mul_cos_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simpa [-abs_mul_cos_add_sin_mul_I] using congr_arg re (abs_mul_cos_add_sin_mul_I x)
state_before: a x✝ z x : ℂ
⊢ abs x * Real.cos x.arg = x.re
state_after: no goals
Theorem: rank_finsupp
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: obtain ⟨⟨_, bs⟩⟩ := Module.Free.exists_basis (R := R) (M := M)
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Free R M
inst✝ : Module.Free R M'
ι : Type w
⊢ Module.rank R (ι →₀ M) = lift.{v, w} #ι * lift.{w, v} (Module.rank R M)
state_after: case intro.mk
R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Free R M
inst✝ : Module.Free R M'
ι : Type w
fst✝ : Type v
bs : Basis fst✝ R M
⊢ Module.rank R (ι →₀ M) = lift.{v, w} #ι * lift.{w, v} (Module.rank R M)

tactic: rw [← bs.mk_eq_rank'', ← (Finsupp.basis fun _ : ι => bs).mk_eq_rank'', Cardinal.mk_sigma,
  Cardinal.sum_const]
state_before: case intro.mk
R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Module.Free R M
inst✝ : Module.Free R M'
ι : Type w
fst✝ : Type v
bs : Basis fst✝ R M
⊢ Module.rank R (ι →₀ M) = lift.{v, w} #ι * lift.{w, v} (Module.rank R M)
state_after: no goals
Theorem: Batteries.RBNode.min?_reverse
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: unfold RBNode.max?
state_before: α : Type u_1
t : RBNode α
⊢ t.reverse.min? = t.max?
state_after: α : Type u_1
t : RBNode α
⊢ t.reverse.min? =
    match t with
    | nil => none
    | node c l v nil => some v
    | node c l v r => r.max?

tactic: split <;> simp [RBNode.min?]
state_before: α : Type u_1
t : RBNode α
⊢ t.reverse.min? =
    match t with
    | nil => none
    | node c l v nil => some v
    | node c l v r => r.max?
state_after: case h_3
α : Type u_1
x✝¹ : RBNode α
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : r✝ = nil → False
⊢ (node c✝ r✝.reverse v✝ l✝.reverse).min? = r✝.max?

tactic: unfold RBNode.min?
state_before: case h_3
α : Type u_1
x✝¹ : RBNode α
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : r✝ = nil → False
⊢ (node c✝ r✝.reverse v✝ l✝.reverse).min? = r✝.max?
state_after: case h_3
α : Type u_1
x✝¹ : RBNode α
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : r✝ = nil → False
⊢ (match node c✝ r✝.reverse v✝ l✝.reverse with
    | nil => none
    | node c nil v r => some v
    | node c l v r => l.min?) =
    r✝.max?

tactic: rw [min?.match_1.eq_3]
state_before: case h_3
α : Type u_1
x✝¹ : RBNode α
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : r✝ = nil → False
⊢ (match node c✝ r✝.reverse v✝ l✝.reverse with
    | nil => none
    | node c nil v r => some v
    | node c l v r => l.min?) =
    r✝.max?
state_after: case h_3
α : Type u_1
x✝¹ : RBNode α
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : r✝ = nil → False
⊢ r✝.reverse.min? = r✝.max?

case h_3.x
α : Type u_1
x✝¹ : RBNode α
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : r✝ = nil → False
⊢ r✝.reverse = nil → False

tactic: apply min?_reverse
state_before: case h_3
α : Type u_1
x✝¹ : RBNode α
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : r✝ = nil → False
⊢ r✝.reverse.min? = r✝.max?
state_after: no goals

tactic: simpa [reverse_eq_iff]
state_before: case h_3.x
α : Type u_1
x✝¹ : RBNode α
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝ : r✝ = nil → False
⊢ r✝.reverse = nil → False
state_after: no goals
Theorem: Ordinal.nfp_add_eq_mul_omega
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: apply le_antisymm (nfp_le_fp (add_isNormal a).monotone hba _)
state_before: a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ nfp (fun x => a + x) b = a * ω
state_after: a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ a * ω ≤ nfp (fun x => a + x) b

a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ a + a * ω ≤ a * ω

tactic: rw [← nfp_add_zero]
state_before: a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ a * ω ≤ nfp (fun x => a + x) b
state_after: a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ nfp (fun x => a + x) 0 ≤ nfp (fun x => a + x) b

tactic: exact nfp_monotone (add_isNormal a).monotone (Ordinal.zero_le b)
state_before: a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ nfp (fun x => a + x) 0 ≤ nfp (fun x => a + x) b
state_after: no goals

tactic: rw [← mul_one_add, one_add_omega]
state_before: a b : Ordinal.{u_1}
hba : b ≤ a * ω
⊢ a + a * ω ≤ a * ω
state_after: no goals
Theorem: PFun.comp_assoc
File: Mathlib/Data/PFun.lean

tactic: simp only [comp_apply, Part.bind_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f✝ : α →. β
f : γ →. δ
g : β →. γ
h : α →. β
x✝¹ : α
x✝ : δ
⊢ x✝ ∈ (f.comp g).comp h x✝¹ ↔ x✝ ∈ f.comp (g.comp h) x✝¹
state_after: no goals
Theorem: MeasureTheory.measure_sUnion₀
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [sUnion_eq_biUnion, measure_biUnion₀ hs hd h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
S : Set (Set α)
hs : S.Countable
hd : S.Pairwise (AEDisjoint μ)
h : ∀ s ∈ S, NullMeasurableSet s μ
⊢ μ (⋃₀ S) = ∑' (s : ↑S), μ ↑s
state_after: no goals
Theorem: CochainComplex.mappingCone.rotateHomotopyEquiv_comm₂
File: Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean

tactic: simpa only [Functor.map_comp]
  using HomotopyCategory.eq_of_homotopy _ _  (rotateHomotopyEquivComm₂Homotopy φ)
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
K L : CochainComplex C ℤ
φ : K ⟶ L
⊢ (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (triangle φ).mor₃ ≫
      (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (rotateHomotopyEquiv φ).hom =
    (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (inr (inr φ))
state_after: no goals
Theorem: sub_sq'
File: Mathlib/Algebra/Ring/Commute.lean

tactic: rw [sub_eq_add_neg, add_sq', neg_sq, mul_neg, ← sub_eq_add_neg]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing R
a b : R
⊢ (a - b) ^ 2 = a ^ 2 + b ^ 2 - 2 * a * b
state_after: no goals