tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.L1.edist_def
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp [Lp.edist_def, snorm, snorm']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1284348
δ : Type ?u.1284351
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : { x // x ∈ Lp β 1 }
⊢ edist f g = ∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ

tactic: simp [edist_eq_coe_nnnorm_sub]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1284348
δ : Type ?u.1284351
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : { x // x ∈ Lp β 1 }
⊢ (∫⁻ (a : α), ↑‖↑↑f a - ↑↑g a‖₊ ∂μ) = ∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ
Theorem: goldConj_neg
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: linarith [one_sub_goldConj, one_lt_gold]
state_before: ⊢ ψ < 0
Theorem: AffineMap.lineMap_apply_module
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: simp [lineMap_apply_module', smul_sub, sub_smul]
state_before: k : Type u_2
V1 : Type u_1
P1 : Type ?u.405790
V2 : Type ?u.405793
P2 : Type ?u.405796
V3 : Type ?u.405799
P3 : Type ?u.405802
V4 : Type ?u.405805
P4 : Type ?u.405808
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
p₀ p₁ : V1
c : k
⊢ ↑(lineMap p₀ p₁) c = (1 - c) • p₀ + c • p₁

tactic: abel
state_before: k : Type u_2
V1 : Type u_1
P1 : Type ?u.405790
V2 : Type ?u.405793
P2 : Type ?u.405796
V3 : Type ?u.405799
P3 : Type ?u.405802
V4 : Type ?u.405805
P4 : Type ?u.405808
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
p₀ p₁ : V1
c : k
⊢ c • p₁ - c • p₀ + p₀ = p₀ - c • p₀ + c • p₁
Theorem: Int.sub_left_lt_of_lt_add
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_right h (-b)
state_before: a b c : Int
h : a < b + c
⊢ a - b < c

tactic: rwa [Int.add_comm b c, Int.add_neg_cancel_right] at h
state_before: a b c : Int
h✝ : a < b + c
h : a + -b < b + c + -b
⊢ a - b < c
Theorem: pow_eq_one_iff_modEq
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [modEq_zero_iff_dvd, orderOf_dvd_iff_pow_eq_one]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
⊢ x ^ n = 1 ↔ n ≡ 0 [MOD orderOf x]
Theorem: Finset.smul_neg
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp_rw [← image_neg]
state_before: F : Type ?u.942371
α : Type u_2
β : Type u_1
γ : Type ?u.942380
inst✝³ : Monoid α
inst✝² : AddGroup β
inst✝¹ : DistribMulAction α β
inst✝ : DecidableEq β
a : α
s : Finset α
t : Finset β
⊢ s • -t = -(s • t)

tactic: exact image_image₂_right_comm smul_neg
state_before: F : Type ?u.942371
α : Type u_2
β : Type u_1
γ : Type ?u.942380
inst✝³ : Monoid α
inst✝² : AddGroup β
inst✝¹ : DistribMulAction α β
inst✝ : DecidableEq β
a : α
s : Finset α
t : Finset β
⊢ s • image (fun x => -x) t = image (fun x => -x) (s • t)
Theorem: ENNReal.zero_rpow_def
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rcases lt_trichotomy (0 : ℝ) y with (H | rfl | H)
state_before: y : ℝ
⊢ 0 ^ y = if 0 < y then 0 else if y = 0 then 1 else ⊤

tactic: simp [H, ne_of_gt, zero_rpow_of_pos, lt_irrefl]
state_before: case inl
y : ℝ
H : 0 < y
⊢ 0 ^ y = if 0 < y then 0 else if y = 0 then 1 else ⊤

tactic: simp [lt_irrefl]
state_before: case inr.inl

⊢ 0 ^ 0 = if 0 < 0 then 0 else if 0 = 0 then 1 else ⊤

tactic: simp [H, asymm H, ne_of_lt, zero_rpow_of_neg]
state_before: case inr.inr
y : ℝ
H : y < 0
⊢ 0 ^ y = if 0 < y then 0 else if y = 0 then 1 else ⊤
Theorem: exists_pos_bound_of_bound
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: gcongr
state_before: V : Type u_1
W : Type u_2
inst✝¹ : SeminormedAddCommGroup V
inst✝ : SeminormedAddCommGroup W
f : V → W
M : ℝ
h : ∀ (x : V), ‖f x‖ ≤ M * ‖x‖
x : V
⊢ M * ‖x‖ ≤ max M 1 * ‖x‖

tactic: apply le_max_left
state_before: case h
V : Type u_1
W : Type u_2
inst✝¹ : SeminormedAddCommGroup V
inst✝ : SeminormedAddCommGroup W
f : V → W
M : ℝ
h : ∀ (x : V), ‖f x‖ ≤ M * ‖x‖
x : V
⊢ M ≤ max M 1
Theorem: one_div_mul_one_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.33748
G : Type ?u.33751
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ 1 / a * (1 / b) = 1 / (a * b)
Theorem: isAlgebraic_one
File: Mathlib/RingTheory/Algebraic.lean

tactic: rw [← _root_.map_one (algebraMap R A)]
state_before: R : Type u
S : Type ?u.92888
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
⊢ IsAlgebraic R 1

tactic: exact isAlgebraic_algebraMap 1
state_before: R : Type u
S : Type ?u.92888
A : Type v
inst✝⁷ : CommRing R
inst✝⁶ : CommRing S
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : IsScalarTower R S A
inst✝ : Nontrivial R
⊢ IsAlgebraic R (↑(algebraMap R A) 1)
Theorem: MeasureTheory.AEEqFun.pair_eq_mk
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: simp only [← pair_mk_mk, mk_coeFn, f.aestronglyMeasurable, g.aestronglyMeasurable]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.392686
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] β
g : α →ₘ[μ] γ
⊢ pair f g = mk (fun x => (↑f x, ↑g x)) (_ : AEStronglyMeasurable (fun x => (↑f x, ↑g x)) μ)
Theorem: Finset.sum_card_slice_div_choose_le_one
File: Mathlib/Combinatorics/SetFamily/LYM.lean

tactic: rw [← sum_flip]
state_before: 𝕜 : Type u_2
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
𝒜 : Finset (Finset α)
s : Finset α
k : ℕ
inst✝ : Fintype α
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
⊢ ∑ r in range (Fintype.card α + 1), ↑(card (𝒜 # r)) / ↑(Nat.choose (Fintype.card α) r) ≤ 1

tactic: refine' (le_card_falling_div_choose le_rfl h𝒜).trans _
state_before: 𝕜 : Type u_2
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
𝒜 : Finset (Finset α)
s : Finset α
k : ℕ
inst✝ : Fintype α
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
⊢ ∑ r in range (Fintype.card α + 1),
      ↑(card (𝒜 # (Fintype.card α - r))) / ↑(Nat.choose (Fintype.card α) (Fintype.card α - r)) ≤
    1

tactic: rw [div_le_iff] <;> norm_cast
state_before: 𝕜 : Type u_2
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
𝒜 : Finset (Finset α)
s : Finset α
k : ℕ
inst✝ : Fintype α
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
⊢ ↑(card (falling (Fintype.card α - Fintype.card α) 𝒜)) /
      ↑(Nat.choose (Fintype.card α) (Fintype.card α - Fintype.card α)) ≤
    1

tactic: simpa only [Nat.sub_self, one_mul, Nat.choose_zero_right, falling] using
  Set.Sized.card_le (sized_falling 0 𝒜)
state_before: 𝕜 : Type u_2
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
𝒜 : Finset (Finset α)
s : Finset α
k : ℕ
inst✝ : Fintype α
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
⊢ card (falling (Fintype.card α - Fintype.card α) 𝒜) ≤ 1 * Nat.choose (Fintype.card α) (Fintype.card α - Fintype.card α)

tactic: rw [tsub_self, choose_zero_right]
state_before: 𝕜 : Type u_2
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
𝒜 : Finset (Finset α)
s : Finset α
k : ℕ
inst✝ : Fintype α
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
⊢ 0 < Nat.choose (Fintype.card α) (Fintype.card α - Fintype.card α)

tactic: exact zero_lt_one
state_before: 𝕜 : Type u_2
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
𝒜 : Finset (Finset α)
s : Finset α
k : ℕ
inst✝ : Fintype α
h𝒜 : IsAntichain (fun x x_1 => x ⊆ x_1) ↑𝒜
⊢ 0 < 1
Theorem: toIocMod_zero_sub_comm
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [← neg_sub, toIocMod_neg, neg_zero]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp 0 (a - b) = p - toIcoMod hp 0 (b - a)
Theorem: FirstOrder.Language.Substructure.comap_id
File: Mathlib/ModelTheory/Substructures.lean

tactic: simp
state_before: L : Language
M : Type w
N : Type ?u.100902
P : Type u_1
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
S✝ : Substructure L M
s : Set M
S : Substructure L P
⊢ ∀ (x : P), x ∈ comap (Hom.id L P) S ↔ x ∈ S
Theorem: OrderHom.lfp_induction
File: Mathlib/Order/FixedPoints.lean

tactic: set s := { a | a ≤ lfp f ∧ p a }
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : CompleteLattice α
f : α →o α
p : α → Prop
step : ∀ (a : α), p a → a ≤ ↑lfp f → p (↑f a)
hSup : ∀ (s : Set α), (∀ (a : α), a ∈ s → p a) → p (sSup s)
⊢ p (↑lfp f)

tactic: specialize hSup s fun a => And.right
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : CompleteLattice α
f : α →o α
p : α → Prop
step : ∀ (a : α), p a → a ≤ ↑lfp f → p (↑f a)
hSup : ∀ (s : Set α), (∀ (a : α), a ∈ s → p a) → p (sSup s)
s : Set α := {a | a ≤ ↑lfp f ∧ p a}
⊢ p (↑lfp f)

tactic: suffices : sSup s = lfp f
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : CompleteLattice α
f : α →o α
p : α → Prop
step : ∀ (a : α), p a → a ≤ ↑lfp f → p (↑f a)
s : Set α := {a | a ≤ ↑lfp f ∧ p a}
hSup : p (sSup s)
⊢ p (↑lfp f)

tactic: exact this ▸ hSup
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : CompleteLattice α
f : α →o α
p : α → Prop
step : ∀ (a : α), p a → a ≤ ↑lfp f → p (↑f a)
s : Set α := {a | a ≤ ↑lfp f ∧ p a}
hSup : p (sSup s)
this : sSup s = ↑lfp f
⊢ p (↑lfp f)

case this
α : Type u
β : Type v
γ : Type w
inst✝ : CompleteLattice α
f : α →o α
p : α → Prop
step : ∀ (a : α), p a → a ≤ ↑lfp f → p (↑f a)
s : Set α := {a | a ≤ ↑lfp f ∧ p a}
hSup : p (sSup s)
⊢ sSup s = ↑lfp f

tactic: have h : sSup s ≤ lfp f := sSup_le fun b => And.left
state_before: case this
α : Type u
β : Type v
γ : Type w
inst✝ : CompleteLattice α
f : α →o α
p : α → Prop
step : ∀ (a : α), p a → a ≤ ↑lfp f → p (↑f a)
s : Set α := {a | a ≤ ↑lfp f ∧ p a}
hSup : p (sSup s)
⊢ sSup s = ↑lfp f

tactic: have hmem : f (sSup s) ∈ s := ⟨f.map_le_lfp h, step _ hSup h⟩
state_before: case this
α : Type u
β : Type v
γ : Type w
inst✝ : CompleteLattice α
f : α →o α
p : α → Prop
step : ∀ (a : α), p a → a ≤ ↑lfp f → p (↑f a)
s : Set α := {a | a ≤ ↑lfp f ∧ p a}
hSup : p (sSup s)
h : sSup s ≤ ↑lfp f
⊢ sSup s = ↑lfp f

tactic: exact h.antisymm (f.lfp_le <| le_sSup hmem)
state_before: case this
α : Type u
β : Type v
γ : Type w
inst✝ : CompleteLattice α
f : α →o α
p : α → Prop
step : ∀ (a : α), p a → a ≤ ↑lfp f → p (↑f a)
s : Set α := {a | a ≤ ↑lfp f ∧ p a}
hSup : p (sSup s)
h : sSup s ≤ ↑lfp f
hmem : ↑f (sSup s) ∈ s
⊢ sSup s = ↑lfp f
Theorem: ModuleCat.MonoidalCategory.associator_naturality_aux
File: Mathlib/Algebra/Category/ModuleCat/Monoidal/Basic.lean

tactic: apply TensorProduct.ext_threefold
state_before: R : Type u
inst✝¹² : CommRing R
X₁ : Type u_1
X₂ : Type u_2
X₃ : Type u_3
inst✝¹¹ : AddCommMonoid X₁
inst✝¹⁰ : AddCommMonoid X₂
inst✝⁹ : AddCommMonoid X₃
inst✝⁸ : Module R X₁
inst✝⁷ : Module R X₂
inst✝⁶ : Module R X₃
Y₁ : Type u_4
Y₂ : Type u_5
Y₃ : Type u_6
inst✝⁵ : AddCommMonoid Y₁
inst✝⁴ : AddCommMonoid Y₂
inst✝³ : AddCommMonoid Y₃
inst✝² : Module R Y₁
inst✝¹ : Module R Y₂
inst✝ : Module R Y₃
f₁ : X₁ →ₗ[R] Y₁
f₂ : X₂ →ₗ[R] Y₂
f₃ : X₃ →ₗ[R] Y₃
⊢ LinearMap.comp (↑(assoc R Y₁ Y₂ Y₃)) (map (map f₁ f₂) f₃) = LinearMap.comp (map f₁ (map f₂ f₃)) ↑(assoc R X₁ X₂ X₃)

tactic: intro x y z
state_before: case H
R : Type u
inst✝¹² : CommRing R
X₁ : Type u_1
X₂ : Type u_2
X₃ : Type u_3
inst✝¹¹ : AddCommMonoid X₁
inst✝¹⁰ : AddCommMonoid X₂
inst✝⁹ : AddCommMonoid X₃
inst✝⁸ : Module R X₁
inst✝⁷ : Module R X₂
inst✝⁶ : Module R X₃
Y₁ : Type u_4
Y₂ : Type u_5
Y₃ : Type u_6
inst✝⁵ : AddCommMonoid Y₁
inst✝⁴ : AddCommMonoid Y₂
inst✝³ : AddCommMonoid Y₃
inst✝² : Module R Y₁
inst✝¹ : Module R Y₂
inst✝ : Module R Y₃
f₁ : X₁ →ₗ[R] Y₁
f₂ : X₂ →ₗ[R] Y₂
f₃ : X₃ →ₗ[R] Y₃
⊢ ∀ (x : X₁) (y : X₂) (z : X₃),
    ↑(LinearMap.comp (↑(assoc R Y₁ Y₂ Y₃)) (map (map f₁ f₂) f₃)) ((x ⊗ₜ[R] y) ⊗ₜ[R] z) =
      ↑(LinearMap.comp (map f₁ (map f₂ f₃)) ↑(assoc R X₁ X₂ X₃)) ((x ⊗ₜ[R] y) ⊗ₜ[R] z)

tactic: rfl
state_before: case H
R : Type u
inst✝¹² : CommRing R
X₁ : Type u_1
X₂ : Type u_2
X₃ : Type u_3
inst✝¹¹ : AddCommMonoid X₁
inst✝¹⁰ : AddCommMonoid X₂
inst✝⁹ : AddCommMonoid X₃
inst✝⁸ : Module R X₁
inst✝⁷ : Module R X₂
inst✝⁶ : Module R X₃
Y₁ : Type u_4
Y₂ : Type u_5
Y₃ : Type u_6
inst✝⁵ : AddCommMonoid Y₁
inst✝⁴ : AddCommMonoid Y₂
inst✝³ : AddCommMonoid Y₃
inst✝² : Module R Y₁
inst✝¹ : Module R Y₂
inst✝ : Module R Y₃
f₁ : X₁ →ₗ[R] Y₁
f₂ : X₂ →ₗ[R] Y₂
f₃ : X₃ →ₗ[R] Y₃
x : X₁
y : X₂
z : X₃
⊢ ↑(LinearMap.comp (↑(assoc R Y₁ Y₂ Y₃)) (map (map f₁ f₂) f₃)) ((x ⊗ₜ[R] y) ⊗ₜ[R] z) =
    ↑(LinearMap.comp (map f₁ (map f₂ f₃)) ↑(assoc R X₁ X₂ X₃)) ((x ⊗ₜ[R] y) ⊗ₜ[R] z)
Theorem: mem_closure_pi
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [mem_closure_iff_nhdsWithin_neBot, nhdsWithin_pi_neBot]
state_before: α✝ : Type ?u.191155
β : Type ?u.191158
γ : Type ?u.191161
δ : Type ?u.191164
inst✝¹ : TopologicalSpace α✝
ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (α i)
I : Set ι
s : (i : ι) → Set (α i)
x : (i : ι) → α i
⊢ x ∈ closure (Set.pi I s) ↔ ∀ (i : ι), i ∈ I → x i ∈ closure (s i)
Theorem: Finset.sum_smul_vsub_const_eq_affineCombination_vsub
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [sum_smul_vsub_eq_affineCombination_vsub, affineCombination_apply_const _ _ _ h]
state_before: k : Type u_1
V : Type u_3
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.344641
s₂ : Finset ι₂
w : ι → k
p₁ : ι → P
p₂ : P
h : ∑ i in s, w i = 1
⊢ ∑ i in s, w i • (p₁ i -ᵥ p₂) = ↑(affineCombination k s p₁) w -ᵥ p₂
Theorem: Int.fract_add_nat
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [fract]
state_before: F : Type ?u.146654
α : Type u_1
β : Type ?u.146660
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
m : ℕ
⊢ fract (a + ↑m) = fract a

tactic: simp
state_before: F : Type ?u.146654
α : Type u_1
β : Type ?u.146660
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
m : ℕ
⊢ a + ↑m - ↑⌊a + ↑m⌋ = fract a
Theorem: CategoryTheory.CostructuredArrow.isSeparating_proj_preimage
File: Mathlib/CategoryTheory/Generator.lean

tactic: refine' fun X Y f g hfg => ext _ _ (h𝒢 _ _ fun G hG h => _)
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
S : C ⥤ D
T : D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢
⊢ IsSeparating ((proj S T).toPrefunctor.obj ⁻¹' 𝒢)

tactic: exact congr_arg CommaMorphism.left (hfg (mk (S.map h ≫ X.hom)) hG (homMk h rfl))
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
S : C ⥤ D
T : D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢
X Y : CostructuredArrow S T
f g : X ⟶ Y
hfg : ∀ (G : CostructuredArrow S T), G ∈ (proj S T).toPrefunctor.obj ⁻¹' 𝒢 → ∀ (h : G ⟶ X), h ≫ f = h ≫ g
G : C
hG : G ∈ 𝒢
h : G ⟶ X.left
⊢ h ≫ f.left = h ≫ g.left
Theorem: Encodable.decode₂_encode
File: Mathlib/Logic/Encodable/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.7117
inst✝ : Encodable α
a : α
⊢ decode₂ α (encode a) = some a

tactic: simp [mem_decode₂, eq_comm, decode₂_eq_some]
state_before: case a
α : Type u_1
β : Type ?u.7117
inst✝ : Encodable α
a a✝ : α
⊢ a✝ ∈ decode₂ α (encode a) ↔ a✝ ∈ some a
Theorem: NFA.toεNFA_εClosure
File: Mathlib/Computability/EpsilonNFA.lean

tactic: ext a
state_before: α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a : α
M : NFA α σ
S : Set σ
⊢ εNFA.εClosure (toεNFA M) S = S

tactic: refine' ⟨_, εNFA.εClosure.base _⟩
state_before: case h
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝ : α
M : NFA α σ
S : Set σ
a : σ
⊢ a ∈ εNFA.εClosure (toεNFA M) S ↔ a ∈ S

tactic: rintro (⟨_, h⟩ | ⟨_, _, h, _⟩)
state_before: case h
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝ : α
M : NFA α σ
S : Set σ
a : σ
⊢ a ∈ εNFA.εClosure (toεNFA M) S → a ∈ S

tactic: exact h
state_before: case h.base
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝ : α
M : NFA α σ
S : Set σ
a : σ
h : a ∈ S
⊢ a ∈ S

tactic: cases h
state_before: case h.step
α : Type u
σ σ' : Type v
M✝ : εNFA α σ
S✝ : Set σ
x : List α
s : σ
a✝¹ : α
M : NFA α σ
S : Set σ
a s✝ : σ
a✝ : εNFA.εClosure (toεNFA M) S s✝
h : a ∈ εNFA.step (toεNFA M) s✝ none
⊢ a ∈ S
Theorem: OnePoint.isClosed_image_coe
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: rw [← isOpen_compl_iff, isOpen_compl_image_coe]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s✝ : Set (OnePoint X)
t s : Set X
⊢ IsClosed (some '' s) ↔ IsClosed s ∧ IsCompact s
Theorem: Real.Icc_eq_closedBall
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [Real.closedBall_eq_Icc, ← sub_div, add_comm, ← sub_add, add_sub_cancel', add_self_div_two, ←
  add_div, add_assoc, add_sub_cancel'_right, add_self_div_two]
state_before: α : Type u
β : Type v
X : Type ?u.201326
ι : Type ?u.201329
inst✝ : PseudoMetricSpace α
x y : ℝ
⊢ Icc x y = closedBall ((x + y) / 2) ((y - x) / 2)
Theorem: List.pairwise_replicate
File: Mathlib/Data/List/Pairwise.lean

tactic: simp
state_before: α✝ : Type ?u.47232
β : Type ?u.47235
R S T : α✝ → α✝ → Prop
a : α✝
l : List α✝
α : Type u_1
r : α → α → Prop
x : α
hx : r x x
⊢ Pairwise r (replicate 0 x)

tactic: simp only [replicate, add_eq, add_zero, pairwise_cons, mem_replicate, ne_eq,
and_imp, forall_eq_apply_imp_iff', hx, implies_true, pairwise_replicate hx n, and_self]
state_before: α✝ : Type ?u.47232
β : Type ?u.47235
R S T : α✝ → α✝ → Prop
a : α✝
l : List α✝
α : Type u_1
r : α → α → Prop
x : α
hx : r x x
n : ℕ
⊢ Pairwise r (replicate (n + 1) x)
Theorem: Nat.Partrec.Code.encode_lt_comp
File: Mathlib/Computability/PartrecCode.lean

tactic: suffices
state_before: cf cg : Code
⊢ encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg)

tactic: exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this
state_before: cf cg : Code
this : ?m.357933
⊢ encode cf < encode (comp cf cg) ∧ encode cg < encode (comp cf cg)

case this
cf cg : Code
⊢ ?m.357933

tactic: change _
state_before: case this
cf cg : Code
⊢ encode (pair cf cg) < encode (comp cf cg)

tactic: simp [encodeCode_eq, encodeCode]
state_before: case this
cf cg : Code
⊢ encode (pair cf cg) < encode (comp cf cg)
Theorem: IsROrC.im_eq_conj_sub
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [← neg_inj, ← ofReal_neg, ← I_mul_re, re_eq_add_conj, map_mul, conj_I, ← neg_div, ← mul_neg,
  neg_sub, mul_sub, neg_mul, sub_eq_add_neg]
state_before: K : Type u_1
E : Type ?u.3572488
inst✝ : IsROrC K
z : K
⊢ ↑(↑im z) = I * (↑(starRingEnd K) z - z) / 2
Theorem: Real.cosh_arsinh
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

tactic: rw [← sqrt_sq (cosh_pos _).le, cosh_sq', sinh_arsinh]
state_before: x✝ y x : ℝ
⊢ cosh (arsinh x) = sqrt (1 + x ^ 2)
Theorem: Ordinal.one_lt_omega
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [Nat.cast_one] using nat_lt_omega 1
state_before: ⊢ 1 < ω
Theorem: CategoryTheory.Arrow.isIso_of_isIso_left_of_isIso_right
File: Mathlib/CategoryTheory/Arrow.lean

tactic: let inverse : g ⟶ f := ⟨inv ff.left, inv ff.right, (by simp)⟩
state_before: T : Type u
inst✝² : Category T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
⊢ ∃ inv, ff ≫ inv = 𝟙 f ∧ inv ≫ ff = 𝟙 g

tactic: apply Exists.intro inverse
state_before: T : Type u
inst✝² : Category T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
inverse : g ⟶ f := CommaMorphism.mk (inv ff.left) (inv ff.right)
⊢ ∃ inv, ff ≫ inv = 𝟙 f ∧ inv ≫ ff = 𝟙 g

tactic: aesop_cat
state_before: T : Type u
inst✝² : Category T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
inverse : g ⟶ f := CommaMorphism.mk (inv ff.left) (inv ff.right)
⊢ ff ≫ inverse = 𝟙 f ∧ inverse ≫ ff = 𝟙 g

tactic: simp
state_before: T : Type u
inst✝² : Category T
f g : Arrow T
ff : f ⟶ g
inst✝¹ : IsIso ff.left
inst✝ : IsIso ff.right
⊢ (𝟭 T).map (inv ff.left) ≫ f.hom = g.hom ≫ (𝟭 T).map (inv ff.right)
Theorem: Filter.cofinite.bliminf_set_eq
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [← compl_inj_iff]
state_before: α : Type u_1
β : Type ?u.181072
γ : Type ?u.181075
ι : Type u_2
p : ι → Prop
s : ι → Set α
⊢ bliminf s cofinite p = {x | Set.Finite {n | p n ∧ ¬x ∈ s n}}

tactic: simp only [bliminf_eq_iSup_biInf, compl_iInf, compl_iSup, ← blimsup_eq_iInf_biSup,
  cofinite.blimsup_set_eq]
state_before: α : Type u_1
β : Type ?u.181072
γ : Type ?u.181075
ι : Type u_2
p : ι → Prop
s : ι → Set α
⊢ bliminf s cofinite pᶜ = {x | Set.Finite {n | p n ∧ ¬x ∈ s n}}ᶜ

tactic: rfl
state_before: α : Type u_1
β : Type ?u.181072
γ : Type ?u.181075
ι : Type u_2
p : ι → Prop
s : ι → Set α
⊢ {x | Set.Infinite {n | p n ∧ x ∈ s nᶜ}} = {x | Set.Finite {n | p n ∧ ¬x ∈ s n}}ᶜ
Theorem: IsPiSystem.prod
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rintro _ ⟨s₁, t₁, hs₁, ht₁, rfl⟩ _ ⟨s₂, t₂, hs₂, ht₂, rfl⟩ hst
state_before: α : Type u_1
α' : Type ?u.23
β : Type u_2
β' : Type ?u.29
γ : Type ?u.32
E : Type ?u.35
C : Set (Set α)
D : Set (Set β)
hC : IsPiSystem C
hD : IsPiSystem D
⊢ IsPiSystem (image2 (fun x x_1 => x ×ˢ x_1) C D)

tactic: rw [prod_inter_prod] at hst ⊢
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
α' : Type ?u.23
β : Type u_2
β' : Type ?u.29
γ : Type ?u.32
E : Type ?u.35
C : Set (Set α)
D : Set (Set β)
hC : IsPiSystem C
hD : IsPiSystem D
s₁ : Set α
t₁ : Set β
hs₁ : s₁ ∈ C
ht₁ : t₁ ∈ D
s₂ : Set α
t₂ : Set β
hs₂ : s₂ ∈ C
ht₂ : t₂ ∈ D
hst : Set.Nonempty ((fun x x_1 => x ×ˢ x_1) s₁ t₁ ∩ (fun x x_1 => x ×ˢ x_1) s₂ t₂)
⊢ (fun x x_1 => x ×ˢ x_1) s₁ t₁ ∩ (fun x x_1 => x ×ˢ x_1) s₂ t₂ ∈ image2 (fun x x_1 => x ×ˢ x_1) C D

tactic: rw [prod_nonempty_iff] at hst
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
α' : Type ?u.23
β : Type u_2
β' : Type ?u.29
γ : Type ?u.32
E : Type ?u.35
C : Set (Set α)
D : Set (Set β)
hC : IsPiSystem C
hD : IsPiSystem D
s₁ : Set α
t₁ : Set β
hs₁ : s₁ ∈ C
ht₁ : t₁ ∈ D
s₂ : Set α
t₂ : Set β
hs₂ : s₂ ∈ C
ht₂ : t₂ ∈ D
hst : Set.Nonempty ((s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂))
⊢ (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) ∈ image2 (fun x x_1 => x ×ˢ x_1) C D

tactic: exact mem_image2_of_mem (hC _ hs₁ _ hs₂ hst.1) (hD _ ht₁ _ ht₂ hst.2)
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
α' : Type ?u.23
β : Type u_2
β' : Type ?u.29
γ : Type ?u.32
E : Type ?u.35
C : Set (Set α)
D : Set (Set β)
hC : IsPiSystem C
hD : IsPiSystem D
s₁ : Set α
t₁ : Set β
hs₁ : s₁ ∈ C
ht₁ : t₁ ∈ D
s₂ : Set α
t₂ : Set β
hs₂ : s₂ ∈ C
ht₂ : t₂ ∈ D
hst : Set.Nonempty (s₁ ∩ s₂) ∧ Set.Nonempty (t₁ ∩ t₂)
⊢ (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) ∈ image2 (fun x x_1 => x ×ˢ x_1) C D