tasksource/leandojo huggingface dataset:
Theorem: Matrix.det_transpose
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [det_apply', det_apply']
state_before: m : Type ?u.1055285
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
⊢ det Mᵀ = det M

tactic: refine' Fintype.sum_bijective _ inv_involutive.bijective _ _ _
state_before: m : Type ?u.1055285
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
⊢ ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, Mᵀ (↑σ i) i = ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, M (↑σ i) i

tactic: intro σ
state_before: m : Type ?u.1055285
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
⊢ ∀ (x : Perm n), ↑↑(↑sign x) * ∏ i : n, Mᵀ (↑x i) i = ↑↑(↑sign x⁻¹) * ∏ i : n, M (↑x⁻¹ i) i

tactic: rw [sign_inv]
state_before: m : Type ?u.1055285
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
⊢ ↑↑(↑sign σ) * ∏ i : n, Mᵀ (↑σ i) i = ↑↑(↑sign σ⁻¹) * ∏ i : n, M (↑σ⁻¹ i) i

tactic: congr 1
state_before: m : Type ?u.1055285
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
⊢ ↑↑(↑sign σ) * ∏ i : n, Mᵀ (↑σ i) i = ↑↑(↑sign σ) * ∏ i : n, M (↑σ⁻¹ i) i

tactic: apply Fintype.prod_equiv σ
state_before: case e_a
m : Type ?u.1055285
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
⊢ ∏ i : n, Mᵀ (↑σ i) i = ∏ i : n, M (↑σ⁻¹ i) i

tactic: intros
state_before: case e_a.h
m : Type ?u.1055285
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
⊢ ∀ (x : n), Mᵀ (↑σ x) x = M (↑σ⁻¹ (↑σ x)) (↑σ x)

tactic: simp
state_before: case e_a.h
m : Type ?u.1055285
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
σ : Perm n
x✝ : n
⊢ Mᵀ (↑σ x✝) x✝ = M (↑σ⁻¹ (↑σ x✝)) (↑σ x✝)
Theorem: Filter.lift_inf
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [Filter.lift, iInf_inf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.21450
ι : Sort ?u.21453
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : Filter α
g h : Set α → Filter β
⊢ (Filter.lift f fun x => g x ⊓ h x) = Filter.lift f g ⊓ Filter.lift f h
Theorem: Complex.real_algHom_eq_id_or_conj
File: Mathlib/Data/Complex/Module.lean

tactic: refine'
    (eq_or_eq_neg_of_sq_eq_sq (f I) I <| by rw [← map_pow, I_sq, map_neg, map_one]).imp _ _ <;>
  refine' fun h => algHom_ext _
state_before: f : ℂ →ₐ[ℝ] ℂ
⊢ f = AlgHom.id ℝ ℂ ∨ f = ↑conjAe

tactic: exacts [h, conj_I.symm ▸ h]
state_before: case refine'_1
f : ℂ →ₐ[ℝ] ℂ
h : ↑f I = I
⊢ ↑f I = ↑(AlgHom.id ℝ ℂ) I

case refine'_2
f : ℂ →ₐ[ℝ] ℂ
h : ↑f I = -I
⊢ ↑f I = ↑↑conjAe I

tactic: rw [← map_pow, I_sq, map_neg, map_one]
state_before: f : ℂ →ₐ[ℝ] ℂ
⊢ ↑f I ^ 2 = I ^ 2
Theorem: Filter.principal_singleton
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [mem_pure, mem_principal, singleton_subset_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.231867
ι : Sort x
a : α
s : Set α
⊢ s ∈ 𝓟 {a} ↔ s ∈ pure a
Theorem: Associated.eq_zero_iff
File: Mathlib/Algebra/Associated.lean

tactic: let ⟨u, hu⟩ := h
state_before: α : Type u_1
β : Type ?u.208063
γ : Type ?u.208066
δ : Type ?u.208069
inst✝ : MonoidWithZero α
a b : α
h : a ~ᵤ b
ha : a = 0
⊢ b = 0

tactic: simp [hu.symm, ha]
state_before: α : Type u_1
β : Type ?u.208063
γ : Type ?u.208066
δ : Type ?u.208069
inst✝ : MonoidWithZero α
a b : α
h : a ~ᵤ b
ha : a = 0
u : αˣ
hu : a * ↑u = b
⊢ b = 0

tactic: let ⟨u, hu⟩ := h.symm
state_before: α : Type u_1
β : Type ?u.208063
γ : Type ?u.208066
δ : Type ?u.208069
inst✝ : MonoidWithZero α
a b : α
h : a ~ᵤ b
hb : b = 0
⊢ a = 0

tactic: simp [hu.symm, hb]
state_before: α : Type u_1
β : Type ?u.208063
γ : Type ?u.208066
δ : Type ?u.208069
inst✝ : MonoidWithZero α
a b : α
h : a ~ᵤ b
hb : b = 0
u : αˣ
hu : b * ↑u = a
⊢ a = 0
Theorem: gcd_dvd_iff_exists
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: simp_rw [mul_comm a, mul_comm b, @eq_comm _ z, ← Ideal.mem_span_pair, ← span_gcd,
  Ideal.mem_span_singleton]
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
a b z : R
⊢ gcd a b ∣ z ↔ ∃ x y, z = a * x + b * y
Theorem: Int.natAbs_add_nonneg
File: Mathlib/Init/Data/Int/Basic.lean

tactic: simp
state_before: n m : ℕ
⊢ 0 ≤ ofNat n → 0 ≤ ofNat m → natAbs (ofNat n + ofNat m) = natAbs (ofNat n) + natAbs (ofNat m)

tactic: simp
state_before: x✝ : ℤ
n : ℕ
⊢ 0 ≤ x✝ → 0 ≤ -[n+1] → natAbs (x✝ + -[n+1]) = natAbs x✝ + natAbs -[n+1]

tactic: simp
state_before: n : ℕ
x✝ : ℤ
⊢ 0 ≤ -[n+1] → 0 ≤ x✝ → natAbs (-[n+1] + x✝) = natAbs -[n+1] + natAbs x✝
Theorem: Cardinal.aleph'_zero
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [← nonpos_iff_eq_zero, ← aleph'_alephIdx 0, aleph'_le]
state_before: ⊢ aleph' 0 = 0

tactic: apply Ordinal.zero_le
state_before: ⊢ 0 ≤ alephIdx 0
Theorem: List.sizeOf_lt_of_mem
File: src/lean/Init/Data/List/BasicAux.lean

tactic: induction h with
| head => simp_arith
| tail _ _ ih => exact Nat.lt_trans ih (by simp_arith)
state_before: α : Type u_1
a : α
inst✝ : SizeOf α
as : List α
h : a ∈ as
⊢ sizeOf a < sizeOf as

tactic: simp_arith
state_before: case head
α : Type u_1
a : α
inst✝ : SizeOf α
as as✝ : List α
⊢ sizeOf a < sizeOf (a :: as✝)

tactic: exact Nat.lt_trans ih (by simp_arith)
state_before: case tail
α : Type u_1
a : α
inst✝ : SizeOf α
as : List α
b✝ : α
as✝ : List α
a✝ : Mem a as✝
ih : sizeOf a < sizeOf as✝
⊢ sizeOf a < sizeOf (b✝ :: as✝)

tactic: simp_arith
state_before: α : Type u_1
a : α
inst✝ : SizeOf α
as : List α
b✝ : α
as✝ : List α
a✝ : Mem a as✝
ih : sizeOf a < sizeOf as✝
⊢ sizeOf as✝ < sizeOf (b✝ :: as✝)
Theorem: ZFSet.IsTransitive.union
File: Mathlib/SetTheory/ZFC/Ordinal.lean

tactic: rw [← sUnion_pair]
state_before: x y z : ZFSet
hx : IsTransitive x
hy : IsTransitive y
⊢ IsTransitive (x ∪ y)

tactic: apply IsTransitive.sUnion' fun z => _
state_before: x y z : ZFSet
hx : IsTransitive x
hy : IsTransitive y
⊢ IsTransitive (⋃₀ {x, y})

tactic: intro
state_before: x y z : ZFSet
hx : IsTransitive x
hy : IsTransitive y
⊢ ∀ (z : ZFSet), z ∈ {x, y} → IsTransitive z

tactic: rw [mem_pair]
state_before: x y z : ZFSet
hx : IsTransitive x
hy : IsTransitive y
z✝ : ZFSet
⊢ z✝ ∈ {x, y} → IsTransitive z✝

tactic: rintro (rfl | rfl)
state_before: x y z : ZFSet
hx : IsTransitive x
hy : IsTransitive y
z✝ : ZFSet
⊢ z✝ = x ∨ z✝ = y → IsTransitive z✝

tactic: assumption'
state_before: case inl
y z : ZFSet
hy : IsTransitive y
z✝ : ZFSet
hx : IsTransitive z✝
⊢ IsTransitive z✝

case inr
x z : ZFSet
hx : IsTransitive x
z✝ : ZFSet
hy : IsTransitive z✝
⊢ IsTransitive z✝
Theorem: Subgroup.normalCore_le
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rw [← mul_one a, ← inv_one, ← one_mul a]
state_before: G : Type u_1
G' : Type ?u.448898
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.448907
inst✝ : AddGroup A
s : Set G
H : Subgroup G
a : G
h : a ∈ normalCore H
⊢ a ∈ H

tactic: exact h 1
state_before: G : Type u_1
G' : Type ?u.448898
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.448907
inst✝ : AddGroup A
s : Set G
H : Subgroup G
a : G
h : a ∈ normalCore H
⊢ 1 * a * 1⁻¹ ∈ H
Theorem: List.mem_finRange
File: Mathlib/Data/List/Range.lean

tactic: cases a
state_before: α : Type u
n : ℕ
a : Fin n
⊢ { val := ↑a, isLt := (_ : ↑a < n) } = a

tactic: rfl
state_before: case mk
α : Type u
n val✝ : ℕ
isLt✝ : val✝ < n
⊢ { val := ↑{ val := val✝, isLt := isLt✝ }, isLt := (_ : ↑{ val := val✝, isLt := isLt✝ } < n) } =
    { val := val✝, isLt := isLt✝ }
Theorem: Function.Involutive.iterate_bit1
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [bit1, ←succ_eq_add_one, iterate_succ, hf.iterate_bit0, comp.left_id]
state_before: α : Type u_1
f : α → α
n✝ : ℕ
hf : Involutive f
n : ℕ
⊢ f^[bit1 n] = f
Theorem: MeasureTheory.AEStronglyMeasurable.prod_swap
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

tactic: rw [← prod_swap] at hf
state_before: α : Type u_2
α' : Type ?u.2385081
β : Type u_3
β' : Type ?u.2385087
γ✝ : Type ?u.2385090
E : Type ?u.2385093
inst✝⁸ : MeasurableSpace α
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ✝
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ✝
inst✝³ : NormedAddCommGroup E
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
f : β × α → γ
hf : AEStronglyMeasurable f (Measure.prod ν μ)
⊢ AEStronglyMeasurable (fun z => f (Prod.swap z)) (Measure.prod μ ν)

tactic: exact hf.comp_measurable measurable_swap
state_before: α : Type u_2
α' : Type ?u.2385081
β : Type u_3
β' : Type ?u.2385087
γ✝ : Type ?u.2385090
E : Type ?u.2385093
inst✝⁸ : MeasurableSpace α
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ✝
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ✝
inst✝³ : NormedAddCommGroup E
γ : Type u_1
inst✝² : TopologicalSpace γ
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
f : β × α → γ
hf : AEStronglyMeasurable f (map Prod.swap (Measure.prod μ ν))
⊢ AEStronglyMeasurable (fun z => f (Prod.swap z)) (Measure.prod μ ν)
Theorem: ZNum.cast_inj
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_int m, ← cast_to_int n, Int.cast_inj (α := α), to_int_inj]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
m n : ZNum
⊢ ↑m = ↑n ↔ m = n
Theorem: Finset.prod_eq_single_of_mem
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: haveI := Classical.decEq α
state_before: ι : Type ?u.371468
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
a : α
h : a ∈ s
h₀ : ∀ (b : α), b ∈ s → b ≠ a → f b = 1
⊢ ∏ x in s, f x = f a

tactic: intro _ H
state_before: case refine'_1
ι : Type ?u.371468
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
a : α
h : a ∈ s
h₀ : ∀ (b : α), b ∈ s → b ≠ a → f b = 1
this : DecidableEq α
⊢ {a} ⊆ s

tactic: rwa [mem_singleton.1 H]
state_before: case refine'_1
ι : Type ?u.371468
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝¹ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
a : α
h : a ∈ s
h₀ : ∀ (b : α), b ∈ s → b ≠ a → f b = 1
this : DecidableEq α
a✝ : α
H : a✝ ∈ {a}
⊢ a✝ ∈ s

tactic: simpa only [mem_singleton]
state_before: case refine'_2
ι : Type ?u.371468
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
a : α
h : a ∈ s
h₀ : ∀ (b : α), b ∈ s → b ≠ a → f b = 1
this : DecidableEq α
⊢ ∀ (x : α), x ∈ s → ¬x ∈ {a} → f x = 1
Theorem: MeasureTheory.lintegral_rw₁
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: dsimp only
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.948452
δ : Type ?u.948455
m : MeasurableSpace α
μ ν : Measure α
f f' : α → β
h✝ : f =ᵐ[μ] f'
g : β → ℝ≥0∞
a : α
h : f a = f' a
⊢ (fun a => g (f a)) a = (fun a => g (f' a)) a

tactic: rw [h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.948452
δ : Type ?u.948455
m : MeasurableSpace α
μ ν : Measure α
f f' : α → β
h✝ : f =ᵐ[μ] f'
g : β → ℝ≥0∞
a : α
h : f a = f' a
⊢ g (f a) = g (f' a)
Theorem: Sum.Not_isLeft
File: Mathlib/Data/Sum/Basic.lean

tactic: simp
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.6982
δ : Type ?u.6985
x y : α ⊕ β
⊢ ¬isLeft x = true ↔ isRight x = true
Theorem: norm_div_eq_zero_iff
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [norm_eq_zero'', div_eq_one]
state_before: 𝓕 : Type ?u.1226326
𝕜 : Type ?u.1226329
α : Type ?u.1226332
ι : Type ?u.1226335
κ : Type ?u.1226338
E : Type u_1
F : Type ?u.1226344
G : Type ?u.1226347
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ ‖a / b‖ = 0 ↔ a = b
Theorem: or_or_distrib_right
File: Std/Logic.lean

tactic: rw [or_or_or_comm, or_self]
state_before: a b c : Prop
⊢ (a ∨ b) ∨ c ↔ (a ∨ c) ∨ b ∨ c
Theorem: Filter.mem_prod_iff_right
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [prod_comm, mem_map, mem_prod_iff_left]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.15882
δ : Type ?u.15885
ι : Sort ?u.15888
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
⊢ s ∈ f ×ˢ g ↔ ∃ t, t ∈ g ∧ ∀ᶠ (x : α) in f, ∀ (y : β), y ∈ t → (x, y) ∈ s

tactic: rfl
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.15882
δ : Type ?u.15885
ι : Sort ?u.15888
s✝ : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
s : Set (α × β)
f : Filter α
g : Filter β
⊢ (∃ t, t ∈ g ∧ ∀ᶠ (y : α) in f, ∀ (x : β), x ∈ t → (x, y) ∈ (fun p => (p.snd, p.fst)) ⁻¹' s) ↔
    ∃ t, t ∈ g ∧ ∀ᶠ (x : α) in f, ∀ (y : β), y ∈ t → (x, y) ∈ s
Theorem: FiniteField.cast_card_eq_zero
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: simp
state_before: K : Type u_1
R : Type ?u.404199
inst✝¹ : Field K
inst✝ : Fintype K
⊢ ↑q = 0
Theorem: Set.ncard_le_one
File: Mathlib/Data/Set/Ncard.lean

tactic: simp_rw [ncard_eq_toFinset_card _ hs, Finset.card_le_one, Finite.mem_toFinset]
state_before: α : Type u_1
β : Type ?u.149272
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
⊢ ncard s ≤ 1 ↔ ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ s → a = b
Theorem: MvPowerSeries.X_dvd_iff
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [← pow_one (X s : MvPowerSeries σ R), X_pow_dvd_iff]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
φ : MvPowerSeries σ R
⊢ X s ∣ φ ↔ ∀ (m : σ →₀ ℕ), ↑m s = 0 → ↑(coeff R m) φ = 0

tactic: constructor <;> intro h m hm
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
φ : MvPowerSeries σ R
⊢ (∀ (m : σ →₀ ℕ), ↑m s < 1 → ↑(coeff R m) φ = 0) ↔ ∀ (m : σ →₀ ℕ), ↑m s = 0 → ↑(coeff R m) φ = 0

tactic: exact h m (hm.symm ▸ zero_lt_one)
state_before: case mp
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s < 1 → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
hm : ↑m s = 0
⊢ ↑(coeff R m) φ = 0

tactic: exact h m (Nat.eq_zero_of_le_zero <| Nat.le_of_succ_le_succ hm)
state_before: case mpr
σ : Type u_1
R : Type u_2
inst✝ : Semiring R
s : σ
φ : MvPowerSeries σ R
h : ∀ (m : σ →₀ ℕ), ↑m s = 0 → ↑(coeff R m) φ = 0
m : σ →₀ ℕ
hm : ↑m s < 1
⊢ ↑(coeff R m) φ = 0
Theorem: Bornology.isBounded_biUnion
File: Mathlib/Topology/Bornology/Basic.lean

tactic: simp only [← isCobounded_compl_iff, compl_iUnion, isCobounded_biInter hs]
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.7851
s✝ : Set α
inst✝ : Bornology α
s : Set ι
f : ι → Set α
hs : Set.Finite s
⊢ IsBounded (⋃ (i : ι) (_ : i ∈ s), f i) ↔ ∀ (i : ι), i ∈ s → IsBounded (f i)
Theorem: Int.lcm_one_right
File: Mathlib/Data/Int/GCD.lean

tactic: rw [Int.lcm]
state_before: i : ℤ
⊢ lcm i 1 = natAbs i

tactic: apply Nat.lcm_one_right
state_before: i : ℤ
⊢ Nat.lcm (natAbs i) (natAbs 1) = natAbs i
Theorem: ManyOneReducible.trans
File: Mathlib/Computability/Reduce.lean

tactic: erw [← h₂, ← h₁]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable γ
p : α → Prop
q : β → Prop
r : γ → Prop
f : α → β
c₁ : Computable f
h₁ : ∀ (a : α), p a ↔ q (f a)
g : β → γ
c₂ : Computable g
h₂ : ∀ (a : β), q a ↔ r (g a)
a : α
h : p a
⊢ r ((g ∘ f) a)

tactic: assumption
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable γ
p : α → Prop
q : β → Prop
r : γ → Prop
f : α → β
c₁ : Computable f
h₁ : ∀ (a : α), p a ↔ q (f a)
g : β → γ
c₂ : Computable g
h₂ : ∀ (a : β), q a ↔ r (g a)
a : α
h : p a
⊢ p a

tactic: rwa [h₁, h₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable γ
p : α → Prop
q : β → Prop
r : γ → Prop
f : α → β
c₁ : Computable f
h₁ : ∀ (a : α), p a ↔ q (f a)
g : β → γ
c₂ : Computable g
h₂ : ∀ (a : β), q a ↔ r (g a)
a : α
h : r ((g ∘ f) a)
⊢ p a
Theorem: differentiableAt_neg_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [neg_neg] using h.neg
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.414413
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.414508
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : DifferentiableAt 𝕜 (fun y => -f y) x
⊢ DifferentiableAt 𝕜 f x
Theorem: CategoryTheory.exact_iso_comp
File: Mathlib/Algebra/Homology/Exact.lean

tactic: rw [← IsIso.inv_hom_id_assoc f g]
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : IsIso f
w : Exact (f ≫ g) h
⊢ Exact g h

tactic: exact exact_epi_comp w
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : IsIso f
w : Exact (f ≫ g) h
⊢ Exact (inv f ≫ f ≫ g) h
Theorem: Real.rpow_add_nat
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simpa using rpow_add_int hx y n
state_before: x✝ y✝ z x : ℝ
hx : x ≠ 0
y : ℝ
n : ℕ
⊢ x ^ (y + ↑n) = x ^ y * x ^ n
Theorem: IsCoprime.of_mul_left_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [mul_comm] at H
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H : IsCoprime (x * y) z
⊢ IsCoprime y z

tactic: exact H.of_mul_left_left
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
H : IsCoprime (y * x) z
⊢ IsCoprime y z
Theorem: Wbtw.trans_left_ne
File: Mathlib/Analysis/Convex/Between.lean

tactic: rintro rfl
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.319792
P : Type u_3
P' : Type ?u.319798
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y z : P
h₁ : Wbtw R w y z
h₂ : Wbtw R w x y
h : y ≠ z
⊢ x ≠ z

tactic: exact h (h₁.swap_right_iff.1 h₂)
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.319792
P : Type u_3
P' : Type ?u.319798
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
w x y : P
h₂ : Wbtw R w x y
h₁ : Wbtw R w y x
h : y ≠ x
⊢ False
Theorem: List.destutter'_cons_neg
File: Mathlib/Data/List/Destutter.lean

tactic: rw [destutter', if_neg h]
state_before: α : Type u_1
l : List α
R : α → α → Prop
inst✝ : DecidableRel R
a b : α
h : ¬R b a
⊢ destutter' R b (a :: l) = destutter' R b l
Theorem: Finset.Ico_filter_le_of_left_le
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext x
state_before: ι : Type ?u.32776
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
inst✝ : DecidablePred ((fun x x_1 => x ≤ x_1) c)
hac : a ≤ c
⊢ filter ((fun x x_1 => x ≤ x_1) c) (Ico a b) = Ico c b

tactic: rw [mem_filter, mem_Ico, mem_Ico, and_comm, and_left_comm]
state_before: case a
ι : Type ?u.32776
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x✝ a b c : α
inst✝ : DecidablePred ((fun x x_1 => x ≤ x_1) c)
hac : a ≤ c
x : α
⊢ x ∈ filter ((fun x x_1 => x ≤ x_1) c) (Ico a b) ↔ x ∈ Ico c b

tactic: exact and_iff_right_of_imp fun h => hac.trans h.1
state_before: case a
ι : Type ?u.32776
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x✝ a b c : α
inst✝ : DecidablePred ((fun x x_1 => x ≤ x_1) c)
hac : a ≤ c
x : α
⊢ a ≤ x ∧ (fun x x_1 => x ≤ x_1) c x ∧ x < b ↔ c ≤ x ∧ x < b
Theorem: mul_lt_mul_of_neg_right
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [mul_neg, neg_lt_neg_iff] using mul_lt_mul_of_pos_right h (neg_pos_of_neg hc)
state_before: α : Type u
β : Type ?u.84801
inst✝ : StrictOrderedRing α
a b c : α
h : b < a
hc : c < 0
⊢ a * c < b * c
Theorem: MeasureTheory.integrable_comp_mul_left_iff
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

tactic: simpa only [smul_eq_mul] using integrable_comp_smul_iff volume g hR
state_before: F : Type u_1
inst✝ : NormedAddCommGroup F
g : ℝ → F
R : ℝ
hR : R ≠ 0
⊢ (Integrable fun x => g (R * x)) ↔ Integrable g
Theorem: Real.mul_lt_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [← inv_div]
state_before: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ 2 / π * x < sin x

tactic: simpa [-inv_div, mul_inv_cancel_left₀ pi_div_two_pos.ne'] using @lt_sin_mul ((π / 2)⁻¹ * x)
  (mul_pos (inv_pos.2 pi_div_two_pos) hx) (by rwa [← div_eq_inv_mul, div_lt_one pi_div_two_pos])
state_before: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ (π / 2)⁻¹ * x < sin x

tactic: rwa [← div_eq_inv_mul, div_lt_one pi_div_two_pos]
state_before: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ (π / 2)⁻¹ * x < 1
Theorem: List.length_eq_one
File: Std/Data/List/Lemmas.lean

tactic: simp [h]
state_before: α : Type u_1
l : List α
x✝ : ∃ a, l = [a]
w✝ : α
h : l = [w✝]
⊢ length l = 1
Theorem: MvPolynomial.comap_eq_id_of_eq_id
File: Mathlib/Data/MvPolynomial/Comap.lean

tactic: convert comap_id_apply x
state_before: σ : Type u_2
τ : Type ?u.140744
υ : Type ?u.140747
R : Type u_1
inst✝ : CommSemiring R
f : MvPolynomial σ R →ₐ[R] MvPolynomial σ R
hf : ∀ (φ : MvPolynomial σ R), ↑f φ = φ
x : σ → R
⊢ comap f x = x

tactic: ext1 φ
state_before: case h.e'_2.h.e'_5
σ : Type u_2
τ : Type ?u.140744
υ : Type ?u.140747
R : Type u_1
inst✝ : CommSemiring R
f : MvPolynomial σ R →ₐ[R] MvPolynomial σ R
hf : ∀ (φ : MvPolynomial σ R), ↑f φ = φ
x : σ → R
⊢ f = AlgHom.id R (MvPolynomial σ R)

tactic: simp [hf, AlgHom.id_apply]
state_before: case h.e'_2.h.e'_5.hf
σ : Type u_2
τ : Type ?u.140744
υ : Type ?u.140747
R : Type u_1
inst✝ : CommSemiring R
f : MvPolynomial σ R →ₐ[R] MvPolynomial σ R
hf : ∀ (φ : MvPolynomial σ R), ↑f φ = φ
x : σ → R
φ : σ
⊢ ↑f (X φ) = ↑(AlgHom.id R (MvPolynomial σ R)) (X φ)
Theorem: Multiset.map_add_right_Ico
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: simp_rw [add_comm _ c]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => x + c) (Ico a b) = Ico (a + c) (b + c)

tactic: exact map_add_left_Ico _ _ _
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Ico a b) = Ico (c + a) (c + b)
Theorem: GeneralizedContinuedFraction.convergents_stable_of_terminated
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

tactic: simp only [convergents, denominators_stable_of_terminated n_le_m terminated_at_n,
  numerators_stable_of_terminated n_le_m terminated_at_n]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n m : ℕ
inst✝ : DivisionRing K
n_le_m : n ≤ m
terminated_at_n : TerminatedAt g n
⊢ convergents g m = convergents g n
Theorem: List.prod_concat
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: rw [concat_eq_append, prod_append, prod_singleton]
state_before: ι : Type ?u.9150
α : Type ?u.9153
M : Type u_1
N : Type ?u.9159
P : Type ?u.9162
M₀ : Type ?u.9165
G : Type ?u.9168
R : Type ?u.9171
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
⊢ prod (concat l a) = prod l * a
Theorem: Submonoid.LocalizationMap.eq'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [f.eq, Localization.r_iff_exists]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.871897
inst✝ : CommMonoid P
f : LocalizationMap S N
a₁ b₁ : M
a₂ b₂ : { x // x ∈ S }
⊢ mk' f a₁ a₂ = mk' f b₁ b₂ ↔ ↑(Localization.r S) (a₁, a₂) (b₁, b₂)