tasksource/leandojo huggingface dataset:
Theorem: affineCombination_mem_convexHull
File: Mathlib/Analysis/Convex/Combination.lean

tactic: rw [affineCombination_eq_centerMass hw₁]
state_before: R : Type u_2
E : Type u_3
F : Type ?u.131675
ι : Type u_1
ι' : Type ?u.131681
α : Type ?u.131684
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s✝ : Set E
i j : ι
c : R
t : Finset ι
w✝ : ι → R
z : ι → E
s : Finset ι
v : ι → E
w : ι → R
hw₀ : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw₁ : Finset.sum s w = 1
⊢ ↑(affineCombination R s v) w ∈ ↑(convexHull R).toOrderHom (Set.range v)

tactic: apply s.centerMass_mem_convexHull hw₀
state_before: R : Type u_2
E : Type u_3
F : Type ?u.131675
ι : Type u_1
ι' : Type ?u.131681
α : Type ?u.131684
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s✝ : Set E
i j : ι
c : R
t : Finset ι
w✝ : ι → R
z : ι → E
s : Finset ι
v : ι → E
w : ι → R
hw₀ : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw₁ : Finset.sum s w = 1
⊢ centerMass s (fun i => w i) v ∈ ↑(convexHull R).toOrderHom (Set.range v)

tactic: simp [hw₁]
state_before: case hws
R : Type u_2
E : Type u_3
F : Type ?u.131675
ι : Type u_1
ι' : Type ?u.131681
α : Type ?u.131684
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s✝ : Set E
i j : ι
c : R
t : Finset ι
w✝ : ι → R
z : ι → E
s : Finset ι
v : ι → E
w : ι → R
hw₀ : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw₁ : Finset.sum s w = 1
⊢ 0 < ∑ i in s, w i

tactic: simp
state_before: case hz
R : Type u_2
E : Type u_3
F : Type ?u.131675
ι : Type u_1
ι' : Type ?u.131681
α : Type ?u.131684
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s✝ : Set E
i j : ι
c : R
t : Finset ι
w✝ : ι → R
z : ι → E
s : Finset ι
v : ι → E
w : ι → R
hw₀ : ∀ (i : ι), i ∈ s → 0 ≤ w i
hw₁ : Finset.sum s w = 1
⊢ ∀ (i : ι), i ∈ s → v i ∈ Set.range v
Theorem: OrderMonoidWithZeroHom.toMonoidWithZeroHom_eq_coe
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: rfl
state_before: F : Type ?u.148141
α : Type u_1
β : Type u_2
γ : Type ?u.148150
δ : Type ?u.148153
hα : Preorder α
hα' : MulZeroOneClass α
hβ : Preorder β
hβ' : MulZeroOneClass β
f : α →*₀o β
⊢ f.toMonoidWithZeroHom = ↑f
Theorem: List.indexOf_inj
File: Mathlib/Data/List/Basic.lean

tactic: have x_eq_y :
    get l ⟨indexOf x l, indexOf_lt_length.2 hx⟩ =
    get l ⟨indexOf y l, indexOf_lt_length.2 hy⟩ := by
  simp only [h]
state_before: ι : Type ?u.94752
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List α
x y : α
hx : x ∈ l
hy : y ∈ l
h : indexOf x l = indexOf y l
⊢ x = y

tactic: simp only [indexOf_get] at x_eq_y
state_before: ι : Type ?u.94752
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List α
x y : α
hx : x ∈ l
hy : y ∈ l
h : indexOf x l = indexOf y l
x_eq_y :
  get l { val := indexOf x l, isLt := (_ : indexOf x l < length l) } =
    get l { val := indexOf y l, isLt := (_ : indexOf y l < length l) }
⊢ x = y

tactic: exact x_eq_y
state_before: ι : Type ?u.94752
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List α
x y : α
hx : x ∈ l
hy : y ∈ l
h : indexOf x l = indexOf y l
x_eq_y : x = y
⊢ x = y

tactic: simp only [h]
state_before: ι : Type ?u.94752
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List α
x y : α
hx : x ∈ l
hy : y ∈ l
h : indexOf x l = indexOf y l
⊢ get l { val := indexOf x l, isLt := (_ : indexOf x l < length l) } =
    get l { val := indexOf y l, isLt := (_ : indexOf y l < length l) }

tactic: subst h
state_before: ι : Type ?u.94752
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List α
x y : α
hx : x ∈ l
hy : y ∈ l
h : x = y
⊢ indexOf x l = indexOf y l

tactic: rfl
state_before: ι : Type ?u.94752
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
l : List α
x : α
hx hy : x ∈ l
⊢ indexOf x l = indexOf x l
Theorem: FirstOrder.Language.Theory.IsMaximal.mem_of_models
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: refine' (h.mem_or_not_mem φ).resolve_right fun con => _
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
h : IsMaximal T
φ : Sentence L
hφ : T ⊨ᵇ φ
⊢ φ ∈ T

tactic: rw [models_iff_not_satisfiable, Set.union_singleton, Set.insert_eq_of_mem con] at hφ
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
h : IsMaximal T
φ : Sentence L
hφ : T ⊨ᵇ φ
con : Formula.not φ ∈ T
⊢ False

tactic: exact hφ h.1
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
h : IsMaximal T
φ : Sentence L
hφ : ¬IsSatisfiable T
con : Formula.not φ ∈ T
⊢ False
Theorem: DifferentiableAt.hasFDerivAt
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: dsimp only [fderiv]
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.256180
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.256275
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 𝕜 f x
⊢ HasFDerivAt f (fderiv 𝕜 f x) x

tactic: dsimp only [DifferentiableAt] at h
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.256180
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.256275
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 𝕜 f x
⊢ HasFDerivAt f (if h : ∃ f', HasFDerivAt f f' x then choose h else 0) x

tactic: rw [dif_pos h]
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.256180
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.256275
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 : ∃ f', HasFDerivAt f f' x
⊢ HasFDerivAt f (if h : ∃ f', HasFDerivAt f f' x then choose h else 0) x

tactic: exact Classical.choose_spec h
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.256180
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.256275
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 : ∃ f', HasFDerivAt f f' x
⊢ HasFDerivAt f (choose h) x
Theorem: Fin.natAdd_castAdd
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n✝ m✝ p m n : ℕ
i : Fin n
⊢ ↑(natAdd m) (↑(castAdd p) i) = ↑(cast (_ : m + n + p = m + (n + p))) (↑(castAdd p) (↑(natAdd m) i))

tactic: simp
state_before: case h
n✝ m✝ p m n : ℕ
i : Fin n
⊢ ↑(↑(natAdd m) (↑(castAdd p) i)) = ↑(↑(cast (_ : m + n + p = m + (n + p))) (↑(castAdd p) (↑(natAdd m) i)))
Theorem: inner_self_nonpos
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← norm_sq_eq_inner, (sq_nonneg _).le_iff_eq, sq_eq_zero_iff, norm_eq_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1688070
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ↑re (inner x x) ≤ 0 ↔ x = 0
Theorem: dite_ne_right_iff
File: Mathlib/Logic/Basic.lean

tactic: simp only [Ne.def, dite_eq_right_iff, not_forall]
state_before: α : Sort u_1
β : Sort ?u.35831
σ : α → Sort ?u.35827
f : α → β
P Q : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ (dite P A fun x => b) ≠ b ↔ ∃ h, A h ≠ b
Theorem: RightCancelMonoid.toMonoid_injective
File: Mathlib/Algebra/Group/Ext.lean

tactic: rintro @⟨@⟨⟩⟩ @⟨@⟨⟩⟩ h
state_before: M : Type u
⊢ Function.Injective (@toMonoid M)

tactic: congr <;> injection h
state_before: case mk.mk.mk.mk
M : Type u
toOne✝¹ : One M
npow✝¹ : ℕ → M → M
npow_zero✝¹ : ∀ (x : M), npow✝¹ 0 x = 1
toSemigroup✝¹ : Semigroup M
mul_right_cancel✝¹ : ∀ (a b c : M), a * b = c * b → a = c
one_mul✝¹ : ∀ (a : M), 1 * a = a
mul_one✝¹ : ∀ (a : M), a * 1 = a
npow_succ✝¹ : ∀ (n : ℕ) (x : M), npow✝¹ (n + 1) x = x * npow✝¹ n x
toOne✝ : One M
npow✝ : ℕ → M → M
npow_zero✝ : ∀ (x : M), npow✝ 0 x = 1
toSemigroup✝ : Semigroup M
mul_right_cancel✝ : ∀ (a b c : M), a * b = c * b → a = c
one_mul✝ : ∀ (a : M), 1 * a = a
mul_one✝ : ∀ (a : M), a * 1 = a
npow_succ✝ : ∀ (n : ℕ) (x : M), npow✝ (n + 1) x = x * npow✝ n x
h : toMonoid = toMonoid
⊢ mk one_mul✝¹ mul_one✝¹ npow✝¹ = mk one_mul✝ mul_one✝ npow✝
Theorem: Polynomial.natDegree_list_sum_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: simp
state_before: R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
l : List S[X]
⊢ natDegree 0 ≤ 0
Theorem: forall_imp_iff_exists_imp
File: Mathlib/Logic/Basic.lean

tactic: let ⟨a⟩ := ha
state_before: ι : Sort ?u.14066
α : Sort u_1
κ : ι → Sort ?u.14068
p q : α → Prop
b : Prop
ha : Nonempty α
⊢ (∀ (x : α), p x) → b ↔ ∃ x, p x → b

tactic: refine ⟨fun h ↦ not_forall_not.1 fun h' ↦ ?_, fun ⟨x, hx⟩ h ↦ hx (h x)⟩
state_before: ι : Sort ?u.14066
α : Sort u_1
κ : ι → Sort ?u.14068
p q : α → Prop
b : Prop
ha : Nonempty α
a : α
⊢ (∀ (x : α), p x) → b ↔ ∃ x, p x → b

tactic: exact if hb : b then h' a fun _ ↦ hb else hb <| h fun x ↦ (not_imp.1 (h' x)).1
state_before: ι : Sort ?u.14066
α : Sort u_1
κ : ι → Sort ?u.14068
p q : α → Prop
b : Prop
ha : Nonempty α
a : α
h : (∀ (x : α), p x) → b
h' : ∀ (x : α), ¬(p x → b)
⊢ False
Theorem: ContDiff.prod_map
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rw [contDiff_iff_contDiffAt] at *
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type ?u.2197996
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
E' : Type u_2
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_3
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
hf : ContDiff 𝕜 n f
hg : ContDiff 𝕜 n g
⊢ ContDiff 𝕜 n (Prod.map f g)

tactic: exact fun ⟨x, y⟩ => (hf x).prod_map (hg y)
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type ?u.2197996
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
E' : Type u_2
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_3
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
hf : ∀ (x : E), ContDiffAt 𝕜 n f x
hg : ∀ (x : E'), ContDiffAt 𝕜 n g x
⊢ ∀ (x : E × E'), ContDiffAt 𝕜 n (Prod.map f g) x
Theorem: MvPolynomial.bind₁_comp_rename
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: ext1 i
state_before: σ : Type u_3
τ : Type u_4
R : Type u_2
S : Type ?u.645310
T : Type ?u.645313
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
υ : Type u_1
f : τ → MvPolynomial υ R
g : σ → τ
⊢ AlgHom.comp (bind₁ f) (rename g) = bind₁ (f ∘ g)

tactic: simp
state_before: case hf
σ : Type u_3
τ : Type u_4
R : Type u_2
S : Type ?u.645310
T : Type ?u.645313
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
υ : Type u_1
f : τ → MvPolynomial υ R
g : σ → τ
i : σ
⊢ ↑(AlgHom.comp (bind₁ f) (rename g)) (X i) = ↑(bind₁ (f ∘ g)) (X i)
Theorem: CategoryTheory.Limits.inl_inr_pushoutAssoc_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [← Category.assoc, Iso.comp_inv_eq, Category.assoc, inr_inl_pushoutAssoc_hom]
state_before: C : Type u
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl)
⊢ pushout.inl ≫ pushout.inr ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv = pushout.inr ≫ pushout.inl
Theorem: Int.neg_log_inv_eq_clog
File: Mathlib/Data/Int/Log.lean

tactic: rw [log_inv, neg_neg]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
⊢ -log b r⁻¹ = clog b r
Theorem: Nat.floor_eq_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← le_floor_iff ha, ← Nat.cast_one, ← Nat.cast_add, ← floor_lt ha, Nat.lt_add_one_iff,
  le_antisymm_iff, and_comm]
state_before: F : Type ?u.36879
α : Type u_1
β : Type ?u.36885
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
ha : 0 ≤ a
⊢ ⌊a⌋₊ = n ↔ ↑n ≤ a ∧ a < ↑n + 1
Theorem: CategoryTheory.IsEquivalence.ofIso_refl
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: rcases hF with ⟨Finv, Funit, Fcounit, Fcomp⟩
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
hF : IsEquivalence F
⊢ ofIso (Iso.refl F) hF = hF

tactic: dsimp [ofIso]
state_before: case mk'
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
Finv : D ⥤ C
Funit : 𝟭 C ≅ F ⋙ Finv
Fcounit : Finv ⋙ F ≅ 𝟭 D
Fcomp : ∀ (X : C), F.map (Funit.hom.app X) ≫ Fcounit.hom.app (F.obj X) = 𝟙 (F.obj X)
⊢ ofIso (Iso.refl F) (mk' Finv Funit Fcounit) = mk' Finv Funit Fcounit

tactic: congr 1 <;> ext X <;> dsimp [NatIso.hcomp]
state_before: case mk'
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
Finv : D ⥤ C
Funit : 𝟭 C ≅ F ⋙ Finv
Fcounit : Finv ⋙ F ≅ 𝟭 D
Fcomp : ∀ (X : C), F.map (Funit.hom.app X) ≫ Fcounit.hom.app (F.obj X) = 𝟙 (F.obj X)
⊢ mk' Finv (Funit ≪≫ hcomp (Iso.refl F) (Iso.refl Finv)) (hcomp (Iso.refl Finv) (Iso.refl F) ≪≫ Fcounit) =
    mk' Finv Funit Fcounit

tactic: simp only [comp_id, map_id]
state_before: case mk'.e_unitIso.w.w.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
Finv : D ⥤ C
Funit : 𝟭 C ≅ F ⋙ Finv
Fcounit : Finv ⋙ F ≅ 𝟭 D
Fcomp : ∀ (X : C), F.map (Funit.hom.app X) ≫ Fcounit.hom.app (F.obj X) = 𝟙 (F.obj X)
X : C
⊢ Funit.hom.app X ≫ 𝟙 (Finv.obj (F.obj X)) ≫ Finv.map (𝟙 (F.obj X)) = Funit.hom.app X

tactic: simp only [id_comp, map_id]
state_before: case mk'.e_counitIso.w.w.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
Finv : D ⥤ C
Funit : 𝟭 C ≅ F ⋙ Finv
Fcounit : Finv ⋙ F ≅ 𝟭 D
Fcomp : ∀ (X : C), F.map (Funit.hom.app X) ≫ Fcounit.hom.app (F.obj X) = 𝟙 (F.obj X)
X : D
⊢ (𝟙 (F.obj (Finv.obj X)) ≫ F.map (𝟙 (Finv.obj X))) ≫ Fcounit.hom.app X = Fcounit.hom.app X
Theorem: ProjectiveSpectrum.le_iff_mem_closure
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

tactic: rw [← as_ideal_le_as_ideal, ← zeroLocus_vanishingIdeal_eq_closure, mem_zeroLocus,
  vanishingIdeal_singleton]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
x y : ProjectiveSpectrum 𝒜
⊢ x ≤ y ↔ y ∈ closure {x}

tactic: simp only [as_ideal_le_as_ideal, coe_subset_coe]
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
x y : ProjectiveSpectrum 𝒜
⊢ x.asHomogeneousIdeal ≤ y.asHomogeneousIdeal ↔ ↑x.asHomogeneousIdeal ⊆ ↑y.asHomogeneousIdeal
Theorem: Nat.ppred_eq_some
File: Mathlib/Data/Nat/PSub.lean

tactic: constructor <;> intro h <;> contradiction
state_before: m : ℕ
⊢ ppred 0 = some m ↔ succ m = 0

tactic: constructor <;> intro h <;> injection h <;> subst m <;> rfl
state_before: m n : ℕ
⊢ ppred (n + 1) = some m ↔ succ m = n + 1
Theorem: Orientation.map_eq_iff_det_pos
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: cases isEmpty_or_nonempty ι
state_before: R : Type u_1
inst✝³ : LinearOrderedField R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : Fintype ι
_i : FiniteDimensional R M
x : Orientation R M ι
f : M ≃ₗ[R] M
h : Fintype.card ι = finrank R M
⊢ ↑(map ι f) x = x ↔ 0 < ↑LinearMap.det ↑f

tactic: rw [map_eq_det_inv_smul _ _ h, units_inv_smul, units_smul_eq_self_iff, LinearEquiv.coe_det]
state_before: case inr
R : Type u_1
inst✝³ : LinearOrderedField R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : Fintype ι
_i : FiniteDimensional R M
x : Orientation R M ι
f : M ≃ₗ[R] M
h : Fintype.card ι = finrank R M
h✝ : Nonempty ι
⊢ ↑(map ι f) x = x ↔ 0 < ↑LinearMap.det ↑f

tactic: have H : finrank R M = 0 := by
  refine' h.symm.trans _
  convert @Fintype.card_of_isEmpty ι _
state_before: case inl
R : Type u_1
inst✝³ : LinearOrderedField R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : Fintype ι
_i : FiniteDimensional R M
x : Orientation R M ι
f : M ≃ₗ[R] M
h : Fintype.card ι = finrank R M
h✝ : IsEmpty ι
⊢ ↑(map ι f) x = x ↔ 0 < ↑LinearMap.det ↑f

tactic: simp [LinearMap.det_eq_one_of_finrank_eq_zero H]
state_before: case inl
R : Type u_1
inst✝³ : LinearOrderedField R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : Fintype ι
_i : FiniteDimensional R M
x : Orientation R M ι
f : M ≃ₗ[R] M
h : Fintype.card ι = finrank R M
h✝ : IsEmpty ι
H : finrank R M = 0
⊢ ↑(map ι f) x = x ↔ 0 < ↑LinearMap.det ↑f

tactic: refine' h.symm.trans _
state_before: R : Type u_1
inst✝³ : LinearOrderedField R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : Fintype ι
_i : FiniteDimensional R M
x : Orientation R M ι
f : M ≃ₗ[R] M
h : Fintype.card ι = finrank R M
h✝ : IsEmpty ι
⊢ finrank R M = 0

tactic: convert @Fintype.card_of_isEmpty ι _
state_before: R : Type u_1
inst✝³ : LinearOrderedField R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : Fintype ι
_i : FiniteDimensional R M
x : Orientation R M ι
f : M ≃ₗ[R] M
h : Fintype.card ι = finrank R M
h✝ : IsEmpty ι
⊢ Fintype.card ι = 0
Theorem: Ideal.jacobson_mono
File: Mathlib/RingTheory/JacobsonIdeal.lean

tactic: intro h x hx
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I J : Ideal R
⊢ I ≤ J → jacobson I ≤ jacobson J

tactic: erw [mem_sInf] at hx⊢
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I J : Ideal R
h : I ≤ J
x : R
hx : x ∈ jacobson I
⊢ x ∈ jacobson J

tactic: exact fun K ⟨hK, hK_max⟩ => hx ⟨Trans.trans h hK, hK_max⟩
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I J : Ideal R
h : I ≤ J
x : R
hx : ∀ ⦃I_1 : Ideal R⦄, I_1 ∈ {J | I ≤ J ∧ IsMaximal J} → x ∈ I_1
⊢ ∀ ⦃I : Ideal R⦄, I ∈ {J_1 | J ≤ J_1 ∧ IsMaximal J_1} → x ∈ I
Theorem: nsmul_eq_mul'
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: induction' n with n ih <;> [rw [zero_nsmul, Nat.cast_zero, mul_zero];
  rw [succ_nsmul', ih, Nat.cast_succ, mul_add, mul_one]]
state_before: α : Type ?u.254897
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : NonAssocSemiring R
a : R
n : ℕ
⊢ n • a = a * ↑n
Theorem: Matrix.updateRow_transpose
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1225606
m : Type u_2
n : Type u_1
o : Type ?u.1225615
m' : o → Type ?u.1225620
n' : o → Type ?u.1225625
R : Type ?u.1225628
S : Type ?u.1225631
α : Type v
β : Type w
γ : Type ?u.1225638
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
⊢ updateRow Mᵀ j c = (updateColumn M j c)ᵀ

tactic: rw [transpose_apply, updateRow_apply, updateColumn_apply]
state_before: case a.h
l : Type ?u.1225606
m : Type u_2
n : Type u_1
o : Type ?u.1225615
m' : o → Type ?u.1225620
n' : o → Type ?u.1225625
R : Type ?u.1225628
S : Type ?u.1225631
α : Type v
β : Type w
γ : Type ?u.1225638
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
i✝ : n
x✝ : m
⊢ updateRow Mᵀ j c i✝ x✝ = (updateColumn M j c)ᵀ i✝ x✝

tactic: rfl
state_before: case a.h
l : Type ?u.1225606
m : Type u_2
n : Type u_1
o : Type ?u.1225615
m' : o → Type ?u.1225620
n' : o → Type ?u.1225625
R : Type ?u.1225628
S : Type ?u.1225631
α : Type v
β : Type w
γ : Type ?u.1225638
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq n
i✝ : n
x✝ : m
⊢ (if i✝ = j then c x✝ else Mᵀ i✝ x✝) = if i✝ = j then c x✝ else M x✝ i✝
Theorem: CategoryTheory.Limits.IsImage.e_isoExt_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp
state_before: C : Type u
inst✝ : Category C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ F'.e ≫ (isoExt hF hF').inv = F.e
Theorem: QuaternionGroup.xa_pow_four
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

tactic: rw [pow_succ, pow_succ, sq, xa_mul_xa, xa_mul_a, xa_mul_xa, add_sub_cancel, add_sub_assoc,
  add_sub_cancel']
state_before: n : ℕ
i : ZMod (2 * n)
⊢ xa i ^ 4 = 1

tactic: norm_cast
state_before: n : ℕ
i : ZMod (2 * n)
⊢ a (↑n + ↑n) = 1

tactic: rw [← two_mul]
state_before: n : ℕ
i : ZMod (2 * n)
⊢ a ↑(n + n) = 1

tactic: simp [one_def]
state_before: n : ℕ
i : ZMod (2 * n)
⊢ a ↑(2 * n) = 1
Theorem: Ordering.swap_orElse
File: Mathlib/Order/Compare.lean

tactic: cases o₁ <;> rfl
state_before: α : Type ?u.9939
β : Type ?u.9942
o₁ o₂ : Ordering
⊢ swap (orElse o₁ o₂) = orElse (swap o₁) (swap o₂)
Theorem: AffineSubspace.nonempty_map
File: Mathlib/LinearAlgebra/AffineSpace/Restrict.lean

tactic: obtain ⟨x, hx⟩ := id Ene
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁶ : Ring k
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : AddCommGroup V₂
inst✝³ : Module k V₁
inst✝² : Module k V₂
inst✝¹ : AddTorsor V₁ P₁
inst✝ : AddTorsor V₂ P₂
E : AffineSubspace k P₁
Ene : Nonempty { x // x ∈ E }
φ : P₁ →ᵃ[k] P₂
⊢ Nonempty { x // x ∈ map φ E }

tactic: refine' ⟨⟨φ x, AffineSubspace.mem_map.mpr ⟨x, hx, rfl⟩⟩⟩
state_before: case intro.mk
k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁶ : Ring k
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : AddCommGroup V₂
inst✝³ : Module k V₁
inst✝² : Module k V₂
inst✝¹ : AddTorsor V₁ P₁
inst✝ : AddTorsor V₂ P₂
E : AffineSubspace k P₁
Ene : Nonempty { x // x ∈ E }
φ : P₁ →ᵃ[k] P₂
x : P₁
hx : x ∈ E
⊢ Nonempty { x // x ∈ map φ E }
Theorem: Int.lcm_self
File: Mathlib/Data/Int/GCD.lean

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

tactic: apply Nat.lcm_self
state_before: i : ℤ
⊢ Nat.lcm (natAbs i) (natAbs i) = natAbs i
Theorem: MvPolynomial.aeval_unique
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: ext i
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝³ : CommSemiring R
inst✝² : CommSemiring S₁
p q : MvPolynomial σ R
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f : σ → S₁
φ : MvPolynomial σ R →ₐ[R] S₁
⊢ φ = aeval (↑φ ∘ X)

tactic: simp
state_before: case hf
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝³ : CommSemiring R
inst✝² : CommSemiring S₁
p q : MvPolynomial σ R
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f : σ → S₁
φ : MvPolynomial σ R →ₐ[R] S₁
i : σ
⊢ ↑φ (X i) = ↑(aeval (↑φ ∘ X)) (X i)
Theorem: Real.lt_log_iff_exp_lt
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← exp_lt_exp, exp_log hy]
state_before: x y : ℝ
hy : 0 < y
⊢ x < log y ↔ exp x < y