theory Ex1
imports Main
begin

lemma True
proof

  subsect {* Basic context elements *}

  {
    fix x
    have "B x" sorry
  }
  thm this

  {
    assume A
    have B sorry
  }
  thm this

  {
    def x == a
    have "B x" sorry
  }
  thm this

  {
    obtain a where "B a" sorry
    have C sorry
  }
  thm this


  subsect {* Contexts vs. rules *}

  {
    fix A B
    fix x :: 'a
    assume "A x"
    have "B x" sorry
  }
  note r = this

  {
    ML_prf {* val ctxt = @{context} *}
    ML_prf {* val (((Ts, ts), [th']), ctxt') =
      Variable.import_thms true [@{thm r}] ctxt *}
  }

qed


section {* Building up contexts in ML *}

subsection {* Variables *}

lemma True
proof

  ML_prf {* val ctxt0 = @{context} *}
  ML_prf {* val (xs, ctxt1) = ctxt0 |> Variable.add_fixes ["x", "y", "z"] *}
  ML_prf {* val t = Syntax.read_term ctxt1 "(x::nat) = y + z" *}
  ML_prf {* val ctxt2 = ctxt1 |> Variable.declare_term t *}
  ML_prf {* Syntax.read_term ctxt2 "x" *}

qed

ML {* val ctxt0 = @{context} *}
ML {* val (xs, ctxt1) = ctxt0 |> Variable.add_fixes ["x", "y", "z"] *}
ML {* val (xs, ctxt1) = ctxt0 |> Variable.variant_fixes ["x", "y", "z"] *}

ML {* Variable.focus (Thm.cprem_of @{thm exE} 2) @{context} *}


subsection {* Assumptions *}

lemma True
proof

ML_prf {* val ctxt0 = @{context} *}
ML_prf {*
  val (asms, ctxt1) = ctxt0
    |> Assumption.add_assumes [@{cprop "x = y"}, @{cprop "y = z"}]
*}
ML_prf {* Assumption.export false ctxt1 ctxt0 (@{thm trans} OF asms) *}


ML_prf {* val ctxt0 = @{context} *}
ML_prf {* val (_, ctxt1) = ctxt0 |> Variable.add_fixes ["x", "y", "z"] *}
ML_prf {* val ts = Syntax.read_props ctxt1 ["x = y", "y = z"] *}
ML_prf {* val ctxt2 = ctxt1 |> fold Variable.declare_term ts *}

ML_prf {*
  val (asms, ctxt3) =
    ctxt2
    |> Assumption.add_assumes (map (cterm_of (ProofContext.theory_of ctxt2)) ts)
*}
ML_prf {* Assumption.export false ctxt3 ctxt0 (@{thm trans} OF asms) *}
ML_prf {* ProofContext.export ctxt3 ctxt0 [@{thm trans} OF asms] *}

qed


subsection {* Local definitions (non-polymorphic) *}

lemma True
proof
  fix x y z :: nat

  ML_prf {* val ctxt0 = @{context} *}
  ML_prf {* val ((a, a_def), ctxt1) =
    ctxt0 |> LocalDefs.add_def ((@{binding a}, NoSyn), @{term "x + y"})
  *}
  ML_prf {* val ((b, b_def), ctxt2) =
    ctxt1 |> LocalDefs.add_def ((@{binding b}, NoSyn), @{term "y + z"})
  *}

  ML_prf {*
    Goal.prove ctxt2 [] [] (Syntax.read_prop ctxt2 "a + b = x + 2 * y + z")
      (fn _ => asm_full_simp_tac (local_simpset_of ctxt2 addsimps [a_def, b_def]) 1)
  *}

qed


subsection {* Local elimination *}

lemma True
proof
  assume ex: "EX x. B x"

  ML_prf {* val ctxt0 = @{context} *}
  ML_prf {* val (([x], [B]), ctxt1) = ctxt0
    |> Obtain.result (fn _ => etac @{thm exE} 1) @{thms ex} *}
  ML_prf {*
    ProofContext.export ctxt1 ctxt0 [Thm.reflexive x]
      handle ERROR msg => (warning msg; []) *}

qed

end